Manage App assets¶

Operations on App assets.

In general, these should be:

Created in top-down order (Connection, then Application, then ApplicationField)
Deleted in bottom-up order (ApplicationField, Application, then Connections)¹

Asset structure¶

Connection¶

An App connection requires a name and qualifiedName. For creation, specific settings are also required to distinguish it as an App connection rather than another type of connection. In addition, at least one of adminRoles, adminGroups, or adminUsers must be provided.

Java Python Kotlin Raw REST API

Create an App connection
String adminRoleGuid = client.getRoleCache().getIdForName("$admin"); // Retrieve the GUID for the admin role, to use later for defining the roles that can administer the connection.

Connection connection = Connection.creator( // Build up the minimum request to create a connection.

        "app-connection", // Provide a human-readable name for your connection, such as production or development.

        AtlanConnectorType.APP, // Set the type of connection to APP.

        List.of(adminRoleGuid), // List the workspace roles that should be able to administer the connection (or null if none). All users with that workspace role (current and future) will be administrators of the connection. Note that the values here need to be the GUID(s) of the workspace role(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

        List.of("group2"), // List the group names that can administer this connection (or null if none). All users within that group (current and future) will be administrators of the connection. Note that the values here are the name(s) of the group(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

        List.of("jsmith")) // List the user names that can administer this connection (or null if none). Note that the values here are the username(s) of the user(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

    .build();
AssetMutationResponse response = connection.save(client); // Actually call Atlan to create the connection. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

String connectionQualifiedName = response.getCreatedAssets().get(0).getQualifiedName(); // Retrieve the qualifiedName for use in subsequent creation calls. (You'd probably want to do some null checking first.)

Create an App connection
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Connection, Application, Table, Schema
from pyatlan.model.enums import AtlanConnectorType

client = AtlanClient()
admin_role_guid = client.role_cache.get_id_for_name("$admin") # Retrieve the GUID for the admin role, to use later for defining the roles that can administer the connection.

connection = Connection.creator( # Build up the minimum request to create a connection.

    name = "app-connection", # Provide a human-readable name for your connection, such as production or development.

    connector_type = AtlanConnectorType.APP, # Set the type of connection to APP.

    admin_roles = [admin_role_guid], # List the workspace roles that should be able to administer the connection (or None if none). All users with that workspace role (current and future) will be administrators of the connection. Note that the values here need to be the GUID(s) of the workspace role(s). At least one of admin_roles, admin_groups, or admin_users must be provided.

    admin_groups = ["group2"], # List the group names that can administer this connection (or None if none). All users within that group (current and future) will be administrators of the connection. Note that the values here are the name(s) of the group(s). At least one of admin_roles, admin_groups, or admin_users must be provided.

    admin_users = ["jsmith"] # List the user names that can administer this connection (or None if none). Note that the values here are the username(s) of the user(s). At least one of admin_roles, admin_groups, or admin_users must be provided.

  ) 

response = client.asset.save(connection) # Actually call Atlan to create the connection.

connection_qualified_name = response.assets_created(asset_type=Connection)[0].qualified_name # Retrieve the qualified_name for use in subsequent creation calls. (You'd probably want to do some null checking first.)

Create an App connection
val adminRoleGuid = client.roleCache.getIdForName("\$admin") // Retrieve the GUID for the admin role, to use later for defining the roles that can administer the connection.

val connection = Connection.creator( // Build up the minimum request to create a connection.

        "app-connection", // Provide a human-readable name for your connection, such as production or development.

        AtlanConnectorType.APP, // Set the type of connection to APP.

        listOf(adminRoleGuid), // List the workspace roles that should be able to administer the connection (or null if none). All users with that workspace role (current and future) will be administrators of the connection. Note that the values here need to be the GUID(s) of the workspace role(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

        listOf("group2"), // List the group names that can administer this connection (or null if none). All users within that group (current and future) will be administrators of the connection. Note that the values here are the name(s) of the group(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

        listOf("jsmith")) // List the user names that can administer this connection (or null if none). Note that the values here are the username(s) of the user(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

    .build()
val response = connection.save(client) // Actually call Atlan to create the connection. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

val connectionQualifiedName = response.createdAssets[0].qualifiedName // Retrieve the qualifiedName for use in subsequent creation calls. (You'd probably want to do some null checking first.)

POST /api/meta/entity/bulk
{
  "entities": [
    {
      "typeName": "Connection", // The typeName must be exactly Connection.

      "attributes": {
        "name": "app-connection", // Human-readable name for your connection, such as production or development.

        "connectorName": "app", // The connectorName must be exactly app.

        "qualifiedName": "default/app/123456789", // The qualifiedName should follow the pattern: default/app/<epoch>, where <epoch> is the time in milliseconds at which the connection is being created.

        "category": "APP", // The category must be APP.

        "adminRoles": [ // List any workspace roles that can administer this connection. All users with that workspace role (current and future) will be administrators of the connection. Note that the values here need to be the GUID(s) of the workspace role(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

          "e7ae0295-c60a-469a-bd2c-fb903943aa02"
        ],
        "adminGroups": [ // List any groups that can administer this connection. All users within that group (current and future) will be administrators of the connection. Note that the values here are the name(s) of the group(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

          "group2"
        ],
        "adminUsers": [ // List any users that can administer this connection. Note that the values here are the username(s) of the user(s). At least one of adminRoles, adminGroups, or adminUsers must be provided.

          "jsmith"
        ]
      }
    }
  ]
}

Access policies

Atlan creates the policies that grant access to a connection, including the ability to retrieve the connection and to create assets within it, asynchronously. It can take several seconds (even up to approximately 30 seconds) before these are in place after creating the connection.

You may therefore need to wait before you'll be able to create the assets below within the connection.

To confirm access, retrieve the connection after it has been created. The SDKs' retry loops will automatically retry until the connection can be successfully retrieved. At that point, your API token has permission to create the other assets.

Note: if you are reusing an existing connection rather than creating one via your API token, you must give your API token a persona that has access to that connection. Otherwise all attempts to create, read, update, or delete assets within that connection will fail due to a lack of permissions.

Application¶

2.6.1 4.0.0

An Application requires a name and a qualifiedName. For creation, you also need to specify the connectionQualifiedName of the connection for the Application. You can also provide the appId and applicationOwnedAssets for the asset.

Java Python Kotlin Raw REST API

Create an Application
Application application = Application.creator( // Build up the minimum request to create an Application.

        "application", // Provide a human-readable name for your Application.

        connectionQualifiedName,) // Provide the qualifiedName of the connection for this asset.
 
    .appId("1234") // (Optional) Provide the appId of this application in the source system.

    .applicationOwnedAssets(List.of(
        Table.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
        Schema.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA"))) // (Optional) Provide the list of assets that exist in this application. Also update the individual assets to hold the qualifiedName of this application in the attribute applicationQualifiedName.

    .build();
AssetMutationResponse response = application.save(client); // Actually call Atlan to create the application. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

Create an Application
application = Application.creator( # Build up the minimum request to create an Application.

    name = "application", # Provide a human-readable name for your Application.

    connection_qualified_name = connection_qualified_name, # Provide the qualified_name of the connection for this Application.

)
application.app_id = "1234", # (Optional) Provide the appId of this application in the source system.

application.application_owned_assets = [
      Table.ref_by_qualified_name("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
      Schema.ref_by_qualified_name("default/snowflake/123456789/DATABASE/SCHEMA")
  ] # (Optional) Provide the list of assets that exist in this application. Also update the individual assets to hold the qualifiedName of this application in the attribute applicationQualifiedName.

response = client.asset.save(application) # Actually call Atlan to create the Application.

application_qualified_name = response.assets_created(asset_type=Application)[0].qualified_name # Retrieve the qualified_name for use in subsequent creation calls. (You'd probably want to do some null checking first.)

Create an Application
val application = Application.creator( // Build up the minimum request to create an Application.

        "application", // Provide a human-readable name for your Application.

        connectionQualifiedName,) // Provide the qualifiedName of the connection for this asset.
 
    .appId("1234") // (Optional) Provide the appId of this application in the source system.

    .applicationOwnedAssets(List.of(
        Table.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
        Schema.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA"))) // (Optional) Provide the list of assets that exist in this application. Also update the individual assets to hold the qualifiedName of this application in the attribute applicationQualifiedName.

    .build()
val response = application.save(client) // Actually call Atlan to create the application. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

POST /api/meta/entity/bulk
{
  "entities": [
    {
      "typeName": "Application", // The typeName must be exactly Application.

      "attributes": {
        "name": "application", // Human-readable name for your asset.

        "qualifiedName": "default/app/123456789/application", // The qualifiedName should follow the pattern: default/app/<epoch>/<assetName>, where default/app/<epoch> is the qualifiedName of the connection for this asset and <assetName> is the name of this asset.

        "connectionQualifiedName": "default/app/123456789", // The connectionQualifiedName must be the exact qualifiedName of the connection for this asset.

        "connectorName": "app", // The connectorName must be exactly app.

        "appId": "1234", // (Optional) The appId should be id of the application in the source system.

        "applicationOwnedAssets": [ // (Optional) The Catalog assets which are present inside this application are added in applicationOwnedAssets attribute.

            {
                "typeName": "Table", // The typeName for this embedded reference must be the type of asset being embeded.

                "uniqueAttributes": { // To complete the reference, you must include a uniqueAttributes object with the qualifiedName of the asset. Note: the asset must already exist in Atlan before creating the path.

                    "qualifiedName": "default/snowflake/123456789/DATABASE/SCHEMA/TABLE"
                }
            },
            {
                "typeName": "Schema",
                "uniqueAttributes": {
                    "qualifiedName": "default/snowflake/123456789/DATABASE/SCHEMA"
                }
            }
        ]
      }
    }
  ]
}

ApplicationField¶

4.2.0 4.2.4

An ApplicationField requires a name and a qualifiedName. For creation, you also need to specify the connectionQualifiedName of the connection for the ApplicationField, and the applicationQualifiedName of the field's ancestor. You can also provide the applicationFieldOwnedAssets for the asset.

Java Python Kotlin Raw REST API

Create an ApplicationField
ApplicationField applicationField = ApplicationField.creator( // Build up the minimum request to create an ApplicationField.

        "application-field", // Provide a human-readable name for your ApplicationField.

        application) // Provide the application for this field.
 
    .applicationFieldOwnedAssets(List.of(
        Table.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
        Schema.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA"))) // (Optional) Provide the list of assets that exist in this ApplicationField. Also update the individual assets to hold the qualifiedName of this ApplicationField in the attribute applicationFieldQualifiedName.

    .build();
AssetMutationResponse response = applicationField.save(client); // Actually call Atlan to create the ApplicationField. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

Create an ApplicationField
applicationField = ApplicationField.creator( # Build up the minimum request to create an ApplicationField.

    name = "application-field", # Provide a human-readable name for your ApplicationField.

    application_qualified_name = application_qualified_name, # Provide the qualified_name of the application for this ApplicationField.

)
applicationField.application_field_owned_assets = [
      Table.ref_by_qualified_name("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
      Schema.ref_by_qualified_name("default/snowflake/123456789/DATABASE/SCHEMA")
  ] # (Optional) Provide the list of assets that exist in this ApplicationField. Also update the individual assets to hold the qualifiedName of this ApplicationField in the attribute applicationFieldQualifiedName.

response = client.asset.save(applicationField) # Actually call Atlan to create the ApplicationField.

Create an ApplicationField
val applicationField = ApplicationField.creator( // Build up the minimum request to create an ApplicationField.

        "application-field", // Provide a human-readable name for your ApplicationField.

        application) // Provide the application for this field.
 
    .applicationFieldOwnedAssets(List.of(
        Table.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA/TABLE"),
        Schema.refByQualifiedName("default/snowflake/123456789/DATABASE/SCHEMA"))) // (Optional) Provide the list of assets that exist in this ApplicationField. Also update the individual assets to hold the qualifiedName of this ApplicationField in the attribute applicationFieldQualifiedName.

    .build()
val response = applicationField.save(client) // Actually call Atlan to create the ApplicationField. Because this operation will persist the asset in Atlan, you must provide it an AtlanClient through which to connect to the tenant.

POST /api/meta/entity/bulk
{
  "entities": [
    {
      "typeName": "ApplicationField", // The typeName must be exactly ApplicationField.

      "attributes": {
        "name": "application-field", // Human-readable name for your asset.

        "qualifiedName": "default/app/123456789/application/field", // The qualifiedName should follow the pattern: default/app/<epoch>/<applicationName>/<fieldName>, where default/app/<epoch>/<applicationName> is the qualifiedName of the application for this field and <fieldName> is the name of this asset.

        "connectionQualifiedName": "default/app/123456789", // The connectionQualifiedName must be the exact qualifiedName of the connection for this asset.

        "connectorName": "app", // The connectorName must be exactly app.

        "parentApplication": { // The application in which this field exists is embedded in the parentApplication attribute.

          "typeName": "Application", // The typeName for this embedded reference must be Application.

          "uniqueAttributes": { // To complete the reference, you must include a uniqueAttributes object with the qualifiedName of the application. Note: the application must already exist in Atlan before creating the path.

            "qualifiedName": "default/app/123456789/application"
          }
        },
        "applicationParentQualifiedName": "default/app/123456789/application", // The applicationParentQualifiedName must be the qualifiedName of the application which contains this field.

        "applicationFieldOwnedAssets": [ // (Optional) The Catalog assets which are present inside this ApplicationField are added in applicationFieldOwnedAssets attribute.

            {
                "typeName": "Table", // The typeName for this embedded reference must be the type of asset being embeded.

                "uniqueAttributes": { // To complete the reference, you must include a uniqueAttributes object with the qualifiedName of the asset. Note: the asset must already exist in Atlan before creating the path.

                    "qualifiedName": "default/snowflake/123456789/DATABASE/SCHEMA/TABLE"
                }
            },
            {
                "typeName": "Schema",
                "uniqueAttributes": {
                    "qualifiedName": "default/snowflake/123456789/DATABASE/SCHEMA"
                }
            }
        ]
      }
    }
  ]
}

Available relationships¶

Every level of the App structure is an Asset, and can therefore be related to the following other assets.

AtlasGlossaryTerm¶

A glossary term provides meaning to an asset. The link terms to assets snippet provides more detail on setting this relationship.

Link¶

A link provides additional context to an asset, by providing a URL to additional information.

Readme¶

A README provides rich documentation for an asset. The add asset READMEs snippet provides more detail on setting this relationship.

Process¶

A process provides lineage information for an asset. An asset can be both an input and an output for one or more processes. The lineage snippets provide more detail on creating and working with lineage.

Although if you want to delete everything in a connection, your better avenue is the packaged connection delete utility in the UI. ↩