1. Einleitung
Apache Atlas ist ein von Apache gehostetes Metadatenverwaltungs- und Governance-Produkt, das derzeit häufig im Bereich Big Data eingesetzt wird. Es kann Unternehmen dabei helfen, Datenbestände zu verwalten, diese Bestände zu klassifizieren und zu verwalten und eine Grundlage für die Datenanalyse bereitzustellen. , Datengovernance Bietet hochwertige Metadateninformationen.
Wenn das Geschäftsvolumen eines Unternehmens allmählich zunimmt, nehmen die Daten von Tag zu Tag zu. Daten aus verschiedenen Geschäftsbereichen können in mehreren Arten von Datenbanken gespeichert und schließlich zur integrierten Analyse im Data Warehouse des Unternehmens gesammelt werden. Wenn Sie möchten, können Sie dies jetzt tun Wenn Sie die Quelle der Daten verfolgen, ist es sinnvoll, die Beziehung zwischen den Daten zu löschen, was äußerst mühsam ist. Wenn bei einer bestimmten Verbindung ein Problem auftritt, sind die Kosten für die Rückverfolgung enorm, weshalb Atlas in diesem Zusammenhang ins Leben gerufen wurde. Dadurch können wir Metadaten sehr bequem verwalten und die Beziehung (Blutbeziehung) zwischen Tabellenebene und Spaltenebene verfolgen, wodurch eine starke Unterstützung und Garantie für die Datenbestände des Unternehmens bereitgestellt wird. Atlas unterstützt das Extrahieren und Verwalten von Metadaten aus HBase, Hive, Sqoop, Storm und Kafka. Gleichzeitig können Sie auch Ihr eigenes Metadatenmodell definieren und Metadaten über die Rest-API generieren.
In diesem Artikel konzentrieren wir uns auf die Einführung der zugehörigen Konzepte von Atlas, um jedem ein besseres Verständnis von Atlas zu ermöglichen. Gleichzeitig erklären wir ausführlich, wie Sie das Datenmodell über die Rest-API anpassen und Blutsverwandtschaften generieren, um Ihre eigenen personalisierten Bedürfnisse zu entwickeln .
2. Atlas-Prinzipien und verwandte Konzepte
Metadaten
Metadaten sind eigentlich Daten, die Daten beschreiben, wie z. B. Tabellen, Felder, Ansichten usw. Jedes Geschäftssystem kann seine eigenen Tabellen, Felder, Ansichten definieren, woher die Daten kommen und wohin sie gehen, ob eine Korrelation zwischen den Daten besteht, und andere Unabhängig davon, ob die Systemdaten doppelte oder widersprüchliche Felder enthalten, sind dies die Probleme, die die Metadatenverwaltung lösen muss, und sie sind auch die Probleme, die Atlas lösen muss.
Funktionsprinzip
Das Prinzip von Atlas ist eigentlich nicht schwer zu verstehen: Es liest hauptsächlich die Datenbankstruktur im Data Warehouse über intern bereitgestellte Skripte, generiert Datenmodelle und speichert sie in der Hbase von Atlas. Gleichzeitig werden Datenänderungen in den Daten überwacht Warehouse durch Hooks und analysiert diese. Die ausgeführte SQL-Anweisung generiert Tabelle-zu-Tabelle- und Spalte-zu-Spalte-Abhängigkeiten, die dem Benutzer an der Rezeption angezeigt werden.
Data-Warehouse-Unterstützung
Atlas bietet die beste Unterstützung für Hive. Wir alle wissen, dass Hive auf Hadoop basiert und Daten in HDFS gespeichert werden. Atlas verfügt über ein spezielles Shell-Skript, das Metadateninformationen wie die Tabellenstruktur von Hive direkt ausführen und lesen und mit dem Atlas-Repository synchronisieren kann .Generieren Sie automatisch ein Metadatenmodell, und der von Atlas bereitgestellte HiveHook kann Änderungen an Hive-Daten überwachen, die Beziehung zwischen Daten basierend auf dem von Hive ausgeführten SQL ableiten und ein Blutsverwandtschaftsdiagramm erstellen. Wenn wir die Metadaten anderer Daten analysieren möchten Speichermedien Daten und Verwandtschaft, Atlas-Unterstützung ist nicht ideal. Normalerweise synchronisieren wir jedoch regelmäßig Daten aus Geschäftsbibliotheken wie MySQL und Oracle zur Integration und Analyse mit dem Data Warehouse. Im Data Warehouse verwenden wir im Allgemeinen das Hadoop-Ökosystem, sodass dies kein Problem darstellt.
Architekturdiagramm
Das Folgende ist ein Architekturdiagramm von Atlas. Es ist ersichtlich, dass das Ökosystem, auf das Atlas angewiesen ist, extrem groß ist, was seine Bereitstellung direkt sehr umständlich macht. In diesem Artikel wird die Bereitstellung von Atlas nicht erläutert. Es gibt viele verwandte Tutorials im Internet . Wenn Sie interessiert sind, können Freunde es selbst suchen und ausprobieren.
Kernkomponentenkonzepte
Atlas verfügt hauptsächlich über die folgenden Kernkomponenten, auf die wir uns konzentrieren müssen. Als nächstes besteht unsere benutzerdefinierte Modellierung durch Rest Api tatsächlich aus den Vorgängen zum Hinzufügen, Löschen, Überprüfen und Ändern der folgenden Komponenten.
1. Geben Sie ein
Die Metadatentypdefinition, bei der es sich um eine Datenbank, eine Tabelle, eine Spalte usw. handeln kann, kann auch in MySQL-Tabelle (mysql_table), Oracle-Tabelle (oracle_table) usw. unterteilt werden. Atlas enthält viele Typen, z. B. DataSet, Process usw. Unter Unter normalen Umständen erben datenbezogene Typen beim Definieren von Typen DataSet, während prozessbezogene Typen Process erben, was die Generierung von Blutsverwandtschaften erleichtert. Wir können den Typ auch anpassen, indem wir die API aufrufen. Dies ist der Ausgangspunkt von allem. Nachdem die Typen definiert wurden, können verschiedene Arten von Metadatenentitäten generiert werden, um Blutsverwandtschaften zu generieren. Ich persönlich bevorzuge es, Metadatentypen als Modellierung zu bezeichnen.
2. Klassifizierung
Laienhaft ausgedrückt bedeutet Klassifizierung die Kennzeichnung von Metadaten. Die Klassifizierung ist übertragbar. Beispielsweise wird Ansicht A basierend auf Tabelle A generiert. Wenn also Tabelle A mit a gekennzeichnet ist, wird Ansicht A automatisch auch mit a gekennzeichnet. Dies hat den Vorteil Erleichtert die Datenverfolgung.
3. Entität
Entitäten stellen spezifische Metadaten dar und die von Atlas verwalteten Objekte sind Entitäten verschiedener Typen.
4. Abstammung
Die Datenherkunft stellt die Übertragungsbeziehung zwischen Daten dar. Durch die Datenherkunft können wir klar erkennen, woher die Daten kommen und wohin sie fließen und welche Vorgänge in der Mitte aufgetreten sind kann schnell zurückverfolgt werden, um den Link zu lokalisieren, in dem es aufgetreten ist. Fehler.
3. Altas-Installation
(Referenzlink, bitte entsprechend der tatsächlichen Situation verwenden)
1. https://blog.csdn.net/hshudoudou/article/details/123899947
2. https://blog.csdn.net/javaThanksgiving/article/details/130505251
4. Verwendung von Altas
Nachdem Altas erfolgreich bereitgestellt wurde, ist es sehr einfach zu verwenden. Dies ist die Anmeldeschnittstelle. Der Standardbenutzername und das Standardkennwort lauten admin, admin:
Gehen Sie zur Startseite und klicken Sie auf „Wechseln zu“. Neu in der oberen rechten Ecke und verwenden Sie die neue Benutzeroberfläche, die intuitiver ist:
Auf der linken Seite der Seite befindet sich der Atlas-Baum. Klicken Sie auf einen Baumknotentyp, um die folgenden Entitäten anzuzeigen . Hier klicken wir auf mysql_table:
Sie können sehen, dass es unten viele Tabellen gibt, die ich zuvor mit Rest Api hochgeladen und definiert habe.
Lassen Sie uns erklären, wie Sie mithilfe der Rest-API Typen anpassen, Entitäten generieren und Blutsverwandtschaften erstellen.
5. Detaillierte Erklärung und Beispiele der Atlas Rest API
Wir klicken oben auf der Homepage auf „Hilfe“ – „API-Dokumentation“, um alle offenen Schnittstellen von Atlas anzuzeigen:
Eine Sache, auf die wir achten müssen, sind die Schnittstellen von Atlas müssen authentifiziert werden, wenn sie verwendet werden. Richtig, also müssen wir beim Erstellen einer HTTP-Anfrage Benutzernamen- und Passwort-Authentifizierungsinformationen mitbringen. In diesem Beispiel verwenden wir die Open-Source-Komponente atlas-client-v2, um Atlas-API-Aufrufe durchzuführen.
In diesem Beispiel definieren wir einen my_db-Typ, einen my_table-Typ, und machen my_db zu einer Eins-zu-viele-my_table. Dann erstellen wir die test_db-Entität unter my_db, erstellen die test_table_source- und test_table_target-Entitäten unter my_table und definieren die Daten von test_table_target so, dass sie von test_table_source stammen , wodurch zwei Entitäten entstehen. Blutsverwandtschaftsabhängigkeit.
Passen Sie die Typen my_db und my_table an
Wir definieren die Typen my_db und my_table. In der Rest-API von Atlas darf eine Anfrage mehrere Typen definieren. Hier erstellen wir zuerst den JSON-Anfragetext und implementieren ihn dann durch Codierung. Wenn man die beiden vergleicht, ist die JSON-Anfrage leichter zu verstehen Der Text lautet wie folgt (an wichtigen Stellen sind Anmerkungen enthalten):
{
"enumDefs": [],
"structDefs": [],
"classificationDefs": [],
//类型定义
"entityDefs": [
{
"name": "my_db",
//数据类型的定义，约定俗成，继承Atlas自带的DataSet
"superTypes": [
"DataSet"
],
//服务类型（便于在界面分组显示类型）
"serviceType": "my_type",
"typeVersion": "1.1",
"attributeDefs": []
},
{
"name": "my_table",
"superTypes": [
"DataSet"
],
"serviceType": "my_type",
"typeVersion": "1.1",
"attributeDefs": []
}
],
//定义类型之间的关系
"relationshipDefs": [
{
"name": "my_table_db",
"serviceType": "my_type",
"typeVersion": "1.1",
//关系类型：ASSOCIATION：关联关系，没有容器存在，1对1
//AGGREGATION：容器关系，1对多，而且彼此可以相互独立存在
//COMPOSITION：容器关系，1对多，但是容器中的实例不能脱离容器存在
"relationshipCategory": "AGGREGATION",
//节点一
"endDef1": {
"type": "my_table",
//表中关联的属性名称，对应下面的 my_db
"name": "db",
//代表这头是不是容器
"isContainer": false,
//cardinality： 三种类型SINGLE, LIST, SET
"cardinality": "SINGLE"
},
// 节点2
"endDef2": {
"type": "my_db",
"name": "tables",
"isContainer": true,
// db 包含 table，table不能重复，所以类型设置为 SET
"cardinality": "SET"
},
// 推导tag NONE 不推导
"propagateTags": "NONE"
}
]
}
Codierungsimplementierung:
Führen Sie die Pom-Abhängigkeit ein. Beachten Sie, dass Sie die Abhängigkeit von slf4j-log4j12 entfernen müssen, wenn Sie sie in Ihr eigenes Geschäftssystem integrieren möchten und das Geschäftssystem andere Protokoll-Frameworks verwendet. Andernfalls kommt es zu Konflikten im Protokoll-Framework und zu Startfehlern Darüber hinaus basiert Atlas-Client-Common auf der Commons-Konfiguration 1.10. Wenn im Geschäftssystem Abhängigkeiten niedrigerer Versionen vorhanden sind, denken Sie daran, diese auszuschließen, da es sonst zu Konflikten zwischen den beiden kommt und die Client-Initialisierung fehlschlägt.
<dependencies>
<!-- Apache Atlas -->
<dependency>
<groupId>org.apache.atlas</groupId>
<artifactId>atlas-client-common</artifactId>
<version>2.1.0</version>
<exclusions>
<exclusion>
<artifactId>slf4j-log4j12</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- Apache Atlas Client Version2 -->
<dependency>
<groupId>org.apache.atlas</groupId>
<artifactId>atlas-client-v2</artifactId>
<version>2.1.0</version>
<exclusions>
<exclusion>
<artifactId>slf4j-log4j12</artifactId>
<groupId>org.slf4j</groupId>
</exclusion>
<exclusion>
<artifactId>log4j</artifactId>
<groupId>log4j</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
</dependencies>
Führen Sie atlas-application.properties ein (muss vorhanden sein, sonst schlägt die Initialisierung fehl):
atlas.rest.address=http://127.0.0.1:21000
Der Code ist wie folgt implementiert (im Vergleich zu JSON sehr einfach zu verstehen):
AtlasClientV2 atlasClientV2 = new AtlasClientV2(new String[]{
"http://127.0.0.1:21000"}, new String[]{
"admin", "admin"});
//父类集合
Set<String> superTypes = new HashSet<>();
superTypes.add(AtlasBaseTypeDef.ATLAS_TYPE_DATASET);
//定义myType
AtlasTypesDef myType = new AtlasTypesDef();
//定义myDb
AtlasEntityDef myDb = new AtlasEntityDef();
myDb.setName("my_db");
myDb.setServiceType("my_type");
myDb.setSuperTypes(superTypes);
myDb.setTypeVersion("1.1");
//定义mytable
AtlasEntityDef myTable = new AtlasEntityDef();
myTable.setName("my_table");
myTable.setServiceType("my_type");
myTable.setSuperTypes(superTypes);
myTable.setTypeVersion("1.1");
//定义relationshipDef
AtlasRelationshipDef relationshipDef = new AtlasRelationshipDef();
relationshipDef.setName("my_table_db");
relationshipDef.setServiceType("my_type");
relationshipDef.setTypeVersion("1.1");
relationshipDef.setRelationshipCategory(AtlasRelationshipDef.RelationshipCategory.AGGREGATION);
relationshipDef.setPropagateTags(AtlasRelationshipDef.PropagateTags.NONE);
//定义endDef1
AtlasRelationshipEndDef endDef1 = new AtlasRelationshipEndDef();
endDef1.setType("my_table");
endDef1.setName("db");
endDef1.setIsContainer(false);
endDef1.setCardinality(AtlasStructDef.AtlasAttributeDef.Cardinality.SINGLE);
relationshipDef.setEndDef1(endDef1);
//定义endDef2
AtlasRelationshipEndDef endDef2 = new AtlasRelationshipEndDef();
endDef2.setType("my_db");
endDef2.setName("tables");
endDef2.setIsContainer(true);
endDef2.setCardinality(AtlasStructDef.AtlasAttributeDef.Cardinality.SET);
relationshipDef.setEndDef2(endDef2);
//entityDefs
List<AtlasEntityDef> entityDefs = new ArrayList<>(2);
entityDefs.add(myDb);
entityDefs.add(myTable);
myType.setEntityDefs(entityDefs);
//relationshipDefs
List<AtlasRelationshipDef> relationshipDefs = new ArrayList<>(1);
relationshipDefs.add(relationshipDef);
myType.setRelationshipDefs(relationshipDefs);
//查询是否已有my_db类型,没有则创建
SearchFilter filter = new SearchFilter();
filter.setParam("name", "my_db");
AtlasTypesDef allTypeDefs = atlasClientV2.getAllTypeDefs(filter);
if (allTypeDefs.getEntityDefs().isEmpty()) {
//请求 rest api
atlasClientV2.createAtlasTypeDefs(myType);
}
Führen Sie den obigen Code aus. Gehen Sie nach der Ausführung zur Atlas-Homepage, um zu sehen, dass der Typ erfolgreich erstellt wurde:
Typmodelldiagramm anzeigen:
Der Typ wird erstellt. Als nächstes erstellen wir die Entität.
Erstellen Sie die Entitäten test_db, test_table_source und test_table_target
json ist wie folgt:
//my_db 实体
{
"typeName": "my_db",
"attributes": {
"qualifiedName": "test_db",
"name": "test_db",
"description": "测试创建db"
}
}
//test_table_source 实体
{
"typeName": "my_table",
"attributes": {
"qualifiedName": "test_table_source",
"name": "test_table_source",
"description": "测试创建test_table_source"
},
"relationshipAttributes": {
"db": {
"typeName": "my_db",
//my_db的guid（创建完my_db后会返回）
"guid": "xxxx"
}
}
}
//test_table_target 实体
{
"typeName": "my_table",
"attributes": {
"qualifiedName": "test_table_target",
"name": "test_table_target",
"description": "测试创建test_table_target"
},
"relationshipAttributes": {
"db": {
"typeName": "my_db",
"guid": "xxx"
}
}
}
Der Code ist wie folgt implementiert:
//创建实体 test_db
AtlasEntity testDb = new AtlasEntity();
testDb.setTypeName("my_db");
Map<String, Object> attributes = new HashMap<>();
attributes.put("qualifiedName", "test_db");
attributes.put("name", "test_db");
attributes.put("description", "测试创建db");
testDb.setAttributes(attributes);
Map<String, String> queryAttributes = new HashMap<>();
queryAttributes.put("qualifiedName", "test_db");
String myDbGuid = null;
try {
//查询不到会报错
AtlasEntity.AtlasEntityWithExtInfo extInfo = atlasClientV2.getEntityByAttribute("my_db", queryAttributes);
myDbGuid = extInfo.getEntity().getGuid();
} catch (AtlasServiceException e) {
if (ClientResponse.Status.NOT_FOUND.equals(e.getStatus())) {
AtlasEntity.AtlasEntityWithExtInfo extInfo = new AtlasEntity.AtlasEntityWithExtInfo(testDb);
//请求
EntityMutationResponse response = atlasClientV2.createEntity(extInfo);
myDbGuid = response.getGuidAssignments().values().toArray(new String[]{
})[0];
}
}
//创建与db的关系
Map<String, Object> relationShipAttr = new HashMap<>();
Map<String, String> dbMap = new HashMap<>();
dbMap.put("guid", myDbGuid);
dbMap.put("typeName", "my_db");
relationShipAttr.put("db", dbMap);
//创建实体 test_table_source
AtlasEntity testTableSource = new AtlasEntity();
testTableSource.setTypeName("my_table");
attributes.put("qualifiedName", "test_table_source");
attributes.put("name", "test_table_source");
attributes.put("description", "测试创建test_table_source");
testTableSource.setAttributes(attributes);
testTableSource.setRelationshipAttributes(relationShipAttr);
queryAttributes.put("qualifiedName", "test_table_source");
try {
//atlasClientV2.updateEntity(new AtlasEntity.AtlasEntityWithExtInfo(testTableSource));
AtlasEntity.AtlasEntityWithExtInfo extInfo = atlasClientV2.getEntityByAttribute("my_table", queryAttributes);
testTableSource = extInfo.getEntity();
} catch (AtlasServiceException e) {
if (ClientResponse.Status.NOT_FOUND.equals(e.getStatus())) {
AtlasEntity.AtlasEntityWithExtInfo extInfo = new AtlasEntity.AtlasEntityWithExtInfo(testTableSource);
//请求
EntityMutationResponse response = atlasClientV2.createEntity(extInfo);
testTableSource.setGuid(response.getGuidAssignments().values().toArray(new String[]{
})[0]);
}
}
//创建实体 test_table_target
AtlasEntity testTableTarget = new AtlasEntity();
testTableTarget.setTypeName("my_table");
attributes.put("qualifiedName", "test_table_target");
attributes.put("name", "test_table_target");
attributes.put("description", "测试创建test_table_target");
testTableTarget.setAttributes(attributes);
testTableTarget.setRelationshipAttributes(relationShipAttr);
queryAttributes.put("qualifiedName", "test_table_target");
try {
//atlasClientV2.updateEntity(new AtlasEntity.AtlasEntityWithExtInfo(testTableTarget));
AtlasEntity.AtlasEntityWithExtInfo extInfo = atlasClientV2.getEntityByAttribute("my_table", queryAttributes);
testTableTarget = extInfo.getEntity();
} catch (AtlasServiceException e) {
if (ClientResponse.Status.NOT_FOUND.equals(e.getStatus())) {
AtlasEntity.AtlasEntityWithExtInfo extInfo = new AtlasEntity.AtlasEntityWithExtInfo(testTableTarget);
//请求
EntityMutationResponse response = atlasClientV2.createEntity(extInfo);
testTableTarget.setGuid(response.getGuidAssignments().values().toArray(new String[]{
})[0]);
}
}
Überprüfen Sie nach der Ausführung des Codes das Baumdiagramm der Klasse und stellen Sie fest, dass Entitäten generiert wurden:
Wenn wir rechts auf die test_db-Entität klicken, können wir ihre grundlegenden Informationen und ihre Beziehungsinformationen sehen, die zwei Entitäten umfassen: test_table_source und test_table_target:
Beziehungsinformationen anzeigen, einschließlich test_table_source und test_table_target:
Erstellen Sie Blutsverwandtschaftsabhängigkeiten von test_table_source und test_table_target
Wie bereits erwähnt, stammen die Daten, die test_table_target definieren, von test_table_source. Die Blutsverwandtschaftsabhängigkeit existiert tatsächlich als Entität in Atlas, aber die geerbte übergeordnete Klasse ist Process. Auf diese Weise können die Eingabe- und Ausgabeattribute definiert werden, um das Blut aufzubauen Beziehung. Der JSON lautet wie folgt:
{
"typeName": "Process",
"attributes": {
"name": "test_process",
"qualifiedName": "test_process",
"description": "test_table_target 的数据来自 test_table_source",
"inputs": [{
"typeName": "my_table",
//test_table_source的guid，创建实体从返回的信息中获取
"guid": "xxx"
}],
"outputs": [{
"typeName": "my_table",
test_table_target的guid，创建实体从返回的信息中获取
"guid": "xxx"
}]
}
}
Der Code ist wie folgt implementiert:
AtlasEntity lineage = new AtlasEntity();
//设置为process类型构建血缘
lineage.setTypeName(AtlasBaseTypeDef.ATLAS_TYPE_PROCESS);
attributes.put("qualifiedName", "test_process");
attributes.put("name", "test_process");
attributes.put("description", "test_table_target 的数据来自 test_table_source");
attributes.put("inputs", getLineAgeInfo(testTableSource));
attributes.put("outputs", getLineAgeInfo(testTableTarget));
lineage.setAttributes(attributes);
queryAttributes.put("qualifiedName", "test_process");
System.out.println(SingletonObject.OBJECT_MAPPER.writeValueAsString(lineage));
try {
//查询是否存在
atlasClientV2.getEntityByAttribute(AtlasBaseTypeDef.ATLAS_TYPE_PROCESS, queryAttributes);
} catch (AtlasServiceException e) {
if (ClientResponse.Status.NOT_FOUND.equals(e.getStatus())) {
//创建
AtlasEntity.AtlasEntityWithExtInfo extInfo = new AtlasEntity.AtlasEntityWithExtInfo(lineage);
atlasClientV2.createEntity(extInfo);
}
}
//构建inputs和outputs
private static List<Map<String, String>> getLineAgeInfo(AtlasEntity entity) {
List<Map<String, String>> list = new ArrayList<>();
Map<String, String> map = new HashMap<>();
map.put("guid", entity.getGuid());
map.put("typeName", entity.getTypeName());
list.add(map);
return list;
}
Führen Sie den obigen Code aus, öffnen Sie dann die Homepage, klicken Sie in my_table auf test_table_source und überprüfen Sie das Abstammungs-Tag. Die Blutsverwandtschaft wurde erfolgreich erstellt:
An diesem Punkt haben wir modelliert uns selbst durch Atlas Rest Api. , die Erstellung der Entität und der Aufbau der Blutsverwandtschaft sind abgeschlossen.
Metadatenmanagement und Datenverwaltung sind heutzutage immer noch ein heißes Thema. Gleichzeitig können sie uns dabei helfen, Unternehmensdatenbestände besser zu unterstützen, Daten besser zu analysieren und wirksame Unterstützung bei Entscheidungen zur Unternehmensentwicklung zu bieten.
引用链接：
1、https://blog.csdn.net/hshudoudou/article/details/123899947
2、https:/ /blog.csdn.net/javaThanksgiving/article/details/130505251
3、原文 https://blog.csdn.net/m0_37719874/article/details/124245209