Définitions de type et création de types personnalisés

Importante

Les fonctionnalités de gouvernance des données de catalogue unifié Microsoft Purview et Microsoft Purview classique (anciennement Azure Purview) sont mises hors service. Microsoft consolide ses fonctionnalités de gouvernance des données dans Microsoft Fabric. Vous ne pouvez plus créer de comptes et les fonctionnalités existantes resteront en mode maintenance jusqu’au 12 novembre 2027. Pour connaître les délais de mise hors service, les conseils de transition et les prochaines étapes recommandées, consultez l’annonce de mise hors service de la gouvernance des données Microsoft Purview.

Ce didacticiel explique ce que sont les définitions de type, comment créer des types personnalisés et comment initialiser les ressources des types personnalisés dans Microsoft Purview.

Dans ce tutoriel, vous allez découvrir :

  • Comment Microsoft Purview utilise le système de type d’Apache Atlas
  • Comment créer un nouveau type personnalisé
  • Comment créer des relations entre les types personnalisés
  • Comment initialiser de nouvelles entités de types personnalisés

Configuration requise

Pour ce tutoriel, vous aurez besoin de :

Remarque

Avant de passer à la partie pratique du didacticiel, les quatre premières sections expliqueront ce qu’est un type de système et comment il est utilisé dans Microsoft Purview. Tous les appels d’API REST décrits ci-dessous utiliseront le jeton du porteur et le point de terminaison qui sont décrits dans les conditions préalables.

Pour passer directement aux étapes, utilisez ces liens :

Que sont les ressources et le type dans Microsoft Purview ?

Une ressource est un élément de métadonnées qui décrit une ressource numérique ou physique. Les ressources numériques ou physiques qui devraient être cataloguées en tant que biens comprennent :

  • Sources de données telles que les bases de données, les fichiers et les flux de données.
  • Modèles et processus analytiques.
  • Politiques et conditions d’utilisation de l’entreprise.
  • comme le serveur.

Microsoft Purview fournit aux utilisateurs un système de type flexible pour étendre la définition de la ressource afin d’inclure de nouveaux types de ressources dès qu’elles deviennent pertinentes. Microsoft Purview s’appuie sur le système Type d’Apache Atlas. Tous les objets de métadonnées (ressources) gérés par Microsoft Purview sont modélisés à l’aide de définitions de type. La compréhension du système de types est essentielle pour créer des types personnalisés dans Microsoft Purview.

Essentiellement, un type peut être considéré comme une classe de la programmation orientée objet (POO) :

  • Elle définit les propriétés qui représentent ce type.
  • Chaque type est identifié de manière unique par son nom.
  • Un type peut hériter d’un supertType. Il s’agit d’un concept équivalent à l’héritage de la POO. Un type qui étend un superType héritera des attributs du superType.

Vous pouvez voir toutes les définitions de type dans votre compte Microsoft Purview en envoyant une GET demande au point de terminaison Toutes les définitions de type :

GET https://{{ENDPOINT}}/catalog/api/atlas/v2/types/typedefs

Apache Atlas a quelques types de systèmes prédéfinis qui sont couramment utilisés comme supertypes.

Par exemple :

  • Référençable : ce type représente toutes les entités qui peuvent être recherchées à l’aide d’un attribut unique appelé qualifiedName.

  • Ressource : Ce type s’étend de Référençable et possède d’autres attributs tels que : nom, description et propriétaire.

  • DataSet : ce type étend Référenceable et Bien. D’un point de vue conceptuel, il peut être utilisé pour représenter un type qui stocke des données. Les types qui étendent DataSet peuvent être censés avoir un schéma. Par exemple, une table SQL.

  • Traçabilité : les informations de traçabilité permettent de comprendre l’origine des données et les transformations qu’elles ont pu subir avant d’arriver dans un fichier ou une table. La traçabilité est calculée via DataSet et Process : les DataSets (entrée du processus) ont un impact sur d’autres DataSets (sortie du processus) via Process.

Diagramme montrant les relations entre les types de systèmes.

Exemple de définition de type

Pour mieux comprendre le système Type, examinons un exemple et voyons comment une table Azure SQL est définie.

Vous pouvez obtenir la définition de type complète en envoyant une GET requête au point de terminaison de définition de type :

GET https://{{ENDPOINT}}/catalog/api/atlas/v2/types/typedef/name/{name}

Conseil

La propriété {name} indique la définition qui vous intéresse. Dans ce cas, utilisez azure_sql_table.

Vous pouvez voir ci-dessous un résultat JSON simplifié :

{
  "category": "ENTITY",
  "guid": "7d92a449-f7e8-812f-5fc8-ca6127ba90bd",
  "name": "azure_sql_table",
  "description": "azure_sql_table",
  "typeVersion": "1.0",
  "serviceType": "Azure SQL Database",
  "options": {
    "schemaElementsAttribute": "columns",
  },
  "attributeDefs": [
    { "name": "principalId", ...},
    { "name": "objectType", ...},
    { "name": "createTime", ...},
    { "name": "modifiedTime", ... }
  ],
  "superTypes": [
    "DataSet",
    "Purview_Table",
    "Table"
  ],
  "subTypes": [],
  "relationshipAttributeDefs": [
    {
      "name": "dbSchema",
      "typeName": "azure_sql_schema",
      "isOptional": false,
      "cardinality": "SINGLE",
      "relationshipTypeName": "azure_sql_schema_tables",
    },
    {
      "name": "columns",
      "typeName": "array<azure_sql_column>",
      "isOptional": true,
      "cardinality": "SET",
      "relationshipTypeName": "azure_sql_table_columns",
    },
  ]
}

Sur la base de la définition du type JSON, examinons certaines propriétés :

  • Le champ Catégorie décrit la catégorie de votre type. La liste des catégories prises en charge par Apache Atlas est disponible ici.

  • Le champ ServiceType est utile lors de la recherche de ressources par type de source dans Microsoft Purview. Le type de service sera un point d’entrée pour rechercher toutes les ressources qui appartiennent au même type de service - tel que défini dans leur définition de type. Dans la capture d’écran ci-dessous de l’interface utilisateur Purview, l’utilisateur limite le résultat aux entités spécifiées avec la base de données Azure SQL dans serviceType :

    Capture d’écran du portail montrant le chemin d’accès de Catalogue unifié vers Parcourir par type de source et la ressource mise en surbrillance.

    Remarque

    La base de données Azure SQL est définie avec le même serviceType que la table Azure SQL.

  • SuperTypes décrit les types « parents » dont vous souhaitez « hériter ».

  • schemaElementsAttributes from options influence ce qui s’affiche dans l’onglet Schéma de votre ressource dans Microsoft Purview.

    Vous pouvez voir ci-dessous un exemple de l’apparence de l’onglet Schéma pour une ressource de type Table Azure SQL :

    Capture d’écran de l’onglet Schéma d’une ressource de table Azure SQL.

  • relationshipAttributeDefs est calculé à partir des définitions de type de relation. Dans notre JSON, nous pouvons voir que schemaElementsAttributes pointe vers l’attribut de relation appelé colonnes - qui est l’un des éléments du tableau relationshipAttributeDefs , comme indiqué ci-dessous :

    ...
    "relationshipAttributeDefs": [
         ...
         {
           "name": "columns",
           "typeName": "array<azure_sql_column>",
           "isOptional": true,
           "cardinality": "SET",
           "relationshipTypeName": "azure_sql_table_columns",
         },
       ]
    

    Chaque relation a sa propre définition. Le nom de la définition se trouve dans l’attribut relationshipTypeName . Dans ce cas, c’est azure_sql_table_columns.

    • La cardinalité de cet attribut de relation est définie sur *SET, ce qui suggère qu’il contient une liste de ressources associées.
    • La ressource associée est de type azure_sql_column, comme visible dans l’attribut typeName .

    En d’autres termes, l’attribut de relation de colonnes associe la table Azure SQL à une liste de colonnes Azure SQL qui apparaissent dans l’onglet Schéma.

Exemple de définition d’un type de relation

Chaque relation se compose de deux extrémités, appelées endDef1 et endDef2.

Dans l’exemple précédent, azure_sql_table_columns était le nom de la relation qui caractérise une table (endDef1) et ses colonnes (endDef2).

Pour obtenir une définition complète, vous pouvez effectuer une GET requête au point de terminaison suivant en utilisant azure_sql_table_columns comme nom :

GET https://{{ENDPOINT}}/catalog/api/atlas/v2/types/typedef/name/azure_sql_table_columns

Vous pouvez voir ci-dessous un résultat JSON simplifié :

{
  "category": "RELATIONSHIP",
  "guid": "c80d0027-8f29-6855-6395-d243b37d8a93",
  "name": "azure_sql_table_columns",
  "description": "azure_sql_table_columns",
  "serviceType": "Azure SQL Database",
  "relationshipCategory": "COMPOSITION",
  "endDef1": {
    "type": "azure_sql_table",
    "name": "columns",
    "isContainer": true,
    "cardinality": "SET",
  },
  "endDef2": {
    "type": "azure_sql_column",
    "name": "table",
    "isContainer": false,
    "cardinality": "SINGLE",
  }
}
  • name est le nom de la définition de la relation. La valeur, dans ce cas, azure_sql_table_columns est utilisée dans l’attribut relationshipTypeName de l’entité qui a cette relation, comme vous pouvez le voir référencé dans le json.

  • relationshipCategory est la catégorie de la relation et peut être COMPOSITION, AGRÉGATION ou ASSOCIATION comme décrit ici.

  • enDef1 est la première extrémité de la définition et contient les attributs :

    • type est le type d’entité que cette relation attend comme end1.

    • name est l’attribut qui apparaîtra sur l’attribut relationnel de cette entité.

    • La cardinalité est soit SINGLE, SET ou LIST.

    • isContainer est une valeur booléenne qui s’applique à la catégorie de relation d’inclusion. Lorsqu’il est défini sur true à une extrémité, cela indique que cette extrémité est le conteneur de l’autre extrémité. Par conséquent :

      • Seules les relations de catégorie de composition ou d’agrégation peuvent et doivent avoir à une extrémité isContainer définie sur true.
      • La propriété isContainer ne doit en aucun cas avoir la propriété isContainer définie sur true.
  • endDef2 est la deuxième extrémité de la définition et décrit, de la même façon que endDef1, les propriétés de la deuxième partie de la relation.

Onglet Schéma

Qu’est-ce que Schema dans Microsoft Purview ?

Le schéma est un concept important qui reflète la façon dont les données sont stockées et organisées dans le magasin de données. Elle reflète la structure des données et les restrictions de données des éléments qui construisent la structure.

Les éléments d’un même schéma peuvent être classés différemment (en raison de leur contenu). De plus, une transformation différente (traçabilité) ne peut se produire que pour un sous-ensemble d’éléments. En raison de ces aspects, Purview peut modéliser des schémas et des éléments de schéma en tant qu’entités, par conséquent, le schéma est généralement un attribut de relation à l’entité de ressource de données. Voici quelques exemples d’éléments de schéma : colonnes d’un tableau, propriétés json du schéma json, éléments XML du schéma XML, etc.

Il existe deux types de schémas :

  • Schéma intrinsèque - Certains systèmes sont intrinsèques au schéma. Par exemple, lorsque vous créez une table SQL, le système vous oblige à définir les colonnes qui construisent la table ; En ce sens, le schéma d’un tableau est reflété par ses colonnes.

    Pour le magasin de données avec un schéma prédéfini, Purview utilise la relation correspondante entre l’actif de données et les éléments de schéma pour refléter le schéma. Cet attribut de relation est spécifié par le mot clé schemaElementsAttribute dans la propriété options de la définition du type d’entité.

  • Schéma non intrinsèque : certains systèmes n’appliquent pas de telles restrictions de schéma, mais les utilisateurs peuvent les utiliser pour stocker des données structurelles en appliquant certains protocoles de schéma aux données. Par exemple, les objets blob Azure stockent des données binaires et ne se soucient pas des données du flux binaire. Par conséquent, il n’a connaissance d’aucun schéma, mais l’utilisateur peut sérialiser ses données avec des protocoles de schéma tels que json avant de les stocker dans l’objet blob. En ce sens, le schéma est maintenu par des protocoles supplémentaires et la validation correspondante est appliquée par l’utilisateur.

    Pour le magasin de données sans schéma inhérent, le modèle de schéma est indépendant de ce magasin de données. Dans de tels cas, Purview définit une interface pour le schéma et une relation entre DataSet et le schéma, appelée dataset_attached_schemas – cela étend tout type d’entité qui hérite de DataSet pour avoir un attribut de relation attachedSchema à lier à leur représentation de schéma.

Exemple d’onglet Schéma

L’exemple de table Azure SQL ci-dessus comporte un schéma intrinsèque. Les informations qui s’affichent dans l’onglet Schéma de la table Azure SQL proviennent de la colonne Azure SQL elle-même.

En sélectionnant un élément de colonne, nous obtenons les informations suivantes :

Capture d’écran de la page de colonne addressID avec l’onglet Propriétés ouvert et le type de données mis en surbrillance.

La question est de savoir comment Microsoft Purview a sélectionné la propriété data_tye dans la colonne et l’a affichée dans l’onglet Schéma du tableau ?

Capture d’écran de la page de table Azure SQL avec la page de schéma ouverte.

Vous pouvez obtenir la définition de type d’une colonne Azure SQL en effectuant une GET requête au point de terminaison :

GET https://{{ENDPOINT}}/catalog/api/atlas/v2/types/typedef/name/{name}

Remarque

{name} dans ce cas est : azure_sql_column

Voici un résultat JSON simplifié :

{
  "category": "ENTITY",
  "guid": "58034a18-fc2c-df30-e474-75803c3a8957",
  "name": "azure_sql_column",
  "description": "azure_sql_column",
  "serviceType": "Azure SQL Database",
  "options": {
    "schemaAttributes": "[\"data_type\"]"
  },
  "attributeDefs": 
  [
    {
      "name": "data_type",
      "typeName": "string",
      "isOptional": false,
      "cardinality": "SINGLE",
      "valuesMinCount": 1,
      "valuesMaxCount": 1,
      "isUnique": false,
      "isIndexable": false,
      "includeInNotification": false
    }, 
  ...
  ]
  ...
}

Remarque

serviceType est Azure SQL Database, identique à celui de la table

  • schemaAttributes est défini sur data_type, qui est l’un des attributs de ce type.

La table Azure SQL a utilisé schemaElementAttribute pour désigner une relation consistant en une liste de colonnes Azure SQL. La définition de type d’une colonne a schemaAttributes defined.

De cette façon, l’onglet Schéma de la table affiche le ou les attributs répertoriés dans les schémaAttributes des actifs associés.

Créer des définitions de type personnalisé

Pourquoi ?

Tout d’abord, pourquoi quelqu’un souhaite-t-il créer une définition de type personnalisée ?

Il peut arriver qu’il n’existe aucun type intégré correspondant à la structure des métadonnées que vous souhaitez importer dans Microsoft Purview.

Dans ce cas, une nouvelle définition de type doit être définie.

Remarque

L’utilisation de types intégrés doit être privilégiée par rapport à la création de types personnalisés, dans la mesure du possible.

Maintenant que nous avons acquis une compréhension des définitions de type en général, nous allons créer des définitions de type personnalisées.

Scénario

Dans ce tutoriel, nous aimerions modéliser une relation 1 :n entre deux types, appelée custom_type_parent et custom_type_child.

Un custom_type_child doit référencer un parent, tandis qu’un custom_type_parent peut référencer une liste d’enfants.

Ils doivent être liés entre eux par une relation 1 :n.

Conseil

Vous trouverez ici quelques conseils lors de la création d’un type personnalisé.

Créer des définitions

  1. Créez la définition de type custom_type_parent en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/types/typedefs

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/types/typedefs

Avec le corps :

 {
    "entityDefs": 
    [
        {
            "category": "ENTITY",
            "version": 1,
            "name": "custom_type_parent",
            "description": "Sample custom type of a parent object",
            "typeVersion": "1.0",
            "serviceType": "Sample-Custom-Types",
            "superTypes": [
                "DataSet"
            ],
            "subTypes": [],
            "options":{
                "schemaElementsAttribute": "columns"
            }
        }
    ]
 }
  1. Créez la définition de type custom_type_child en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/types/typedefs

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/types/typedefs

Avec le corps :

 {
    "entityDefs": 
    [
        {
            "category": "ENTITY",
            "version": 1,
            "name": "custom_type_child",
            "description": "Sample custom type of a CHILD object",
            "typeVersion": "1.0",
            "serviceType": "Sample-Custom-Types",
            "superTypes": [
                "DataSet"
            ],
            "subTypes": [],
            "options":{
               "schemaAttributes": "data_type"
            }
        }
    ]
 }
  1. Créez une définition de relation de type personnalisée en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/types/typedefs

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/types/typedefs

Avec le corps :

{
    "relationshipDefs": [
        {
            "category": "RELATIONSHIP",
            "endDef1" : {
                "cardinality" : "SET",
                "isContainer" : true,
                "name" : "Children",
                "type" : "custom_type_parent"
            },
            "endDef2" : {
                "cardinality" : "SINGLE",
                "isContainer" : false,
                "name" : "Parent",
                "type" : "custom_type_child"
            },
            "relationshipCategory" : "COMPOSITION",
            "serviceType": "Sample-Custom-Types",
            "name": "custom_parent_child_relationship"
        }
    ]
}

Initialiser des ressources de types personnalisés

  1. Initialisez une nouvelle ressource de type custom_type_parent en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/entity

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/entity

Avec le corps :


{
    "entity": {
        "typeName":"custom_type_parent",
        "status": "ACTIVE",
        "version": 1,
         "attributes":{
            "name": "First_parent_object",
            "description": "This is the first asset of type custom_type_parent",
            "qualifiedName": "custom//custom_type_parent:First_parent_object"
         }

    }
}

Enregistrez le GUID car vous en aurez besoin ultérieurement.

  1. Initialisez une nouvelle ressource de type custom_type_child en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/entity

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/entity

Avec le corps :

{
   "entity": {
       "typeName":"custom_type_child",
       "status": "ACTIVE",
       "version": 1,
       "attributes":{
           "name": "First_child_object",
           "description": "This is the first asset of type custom_type_child",
           "qualifiedName": "custom//custom_type_child:First_child_object"
        }
   }
}

Enregistrez le GUID car vous en aurez besoin ultérieurement.

  1. Initialisez une nouvelle relation de type custom_parent_child_relationship en effectuant une POST requête à l’un des deux points de terminaison suivants :

Portail de gouvernance Microsoft Purview classique :

POST https://{{ENDPOINT}}.purview.azure.com/catalog/api/atlas/v2/relationship/

Nouveau portail Microsoft Purview :

POST https://api.purview-service.microsoft.com/catalog/api/atlas/v2/relationship/

Avec le corps suivant :

Remarque

Le GUID de end1 doit être remplacé par le GUID de l’objet créé à l’étape 6.1 Le GUID de end2 doit être remplacé par le GUID de l’objet créé à l’étape 6.2

{
   "typeName": "custom_parent_child_relationship",
   "end1": {
         "guid": "...",
       "typeName": "custom_type_parent"
   },
   "end2": {
       "guid": "...",
       "typeName": "custom_type_child"
   }
}

Afficher les ressources dans Microsoft Purview

  1. Accédez au Catalogue unifié dans Microsoft Purview.

  2. Sélectionnez Parcourir.

  3. Sélectionner par type de source.

  4. Sélectionnez sample-custom-types.

    Capture d’écran montrant le chemin d’accès du catalogue unifié pour parcourir les ressources avec le filtre réduit à Sample-Custom-Types.

  5. Sélectionnez le First_parent_object :

    Capture d’écran de la page First_parent_object.

  6. Sélectionnez l’onglet Propriétés :

    Capture d’écran de l’onglet Propriétés avec les ressources associées mises en surbrillance, montrant une ressource enfant.

  7. Vous pouvez voir le First_child_object lié à cet emplacement.

  8. Sélectionnez le First_child_object :

    Capture d’écran de la page First_child_object montrant l’onglet vue d’ensemble.

  9. Sélectionnez l’onglet Propriétés :

    Capture d’écran de la page des propriétés, montrant les ressources associées avec une ressource parent unique.

  10. Vous pouvez voir que l’objet parent est lié à cet endroit.

  11. De même, vous pouvez sélectionner l’onglet Associé pour voir la relation entre les deux objets :

    Capture d’écran de l’onglet Associé, montrant la relation entre l’enfant et le parent.

  12. Vous pouvez créer plusieurs enfants en initialisant une nouvelle ressource enfant et en initiant une relation

    Remarque

    Le qualifiedName est unique par ressource. Par conséquent, le deuxième enfant doit être appelé différemment, par exemple : custom//custom_type_child :Second_child_object

    Capture d’écran du First_parent_object montrant les deux ressources enfants mises en surbrillance.

    Conseil

    Si vous supprimez le First_parent_object vous remarquerez que les enfants seront également supprimés, en raison de la relation COMPOSITION que nous avons choisie dans la définition.

Limitations

Il existe plusieurs limitations connues lors de l’utilisation de types personnalisés qui seront améliorés à l’avenir, telles que :

  • L’onglet Relations est différent des types intégrés
  • Les types personnalisés n’ont pas d’icônes
  • La hiérarchie n’est pas prise en charge

Étapes suivantes