Native Applications#
Native Applications are containerized web applications that run on Edge resources. They provide a frontend web user interface, with backends that perform long running computational tasks. Native Applications can be run on a variety of Compute Profiles that feature a variety of memory sizes, CPU counts and GPU counts.
When a user launches a Native Application, Edge will create and host an individual instance for that user. Edge Compute Profiles can be assigned more computational resources than a traditional Desktop application. Users are free to interacting with the Native Application while long running compute tasks run on Edge in the background without tying up local Desktop resources.
Native Applications also have access to Edge data resources such as Edge hosted files. They can perform tasks on files without having to transfer them to a user's Desktop system. In addition, they benefit from Edge's Authentication system.
Compute Profiles#
Applications instances can be started with a recommended profile, or one may be selected by a user by opening the Application tile's start menu and selecting a Compute Profile


When registering an application, an application can use predefined Compute Profiles:
Profile Name |
Display Name |
CPUs |
GPUs |
Memory in Gb |
---|---|---|---|---|
|
small |
2 |
0 |
1.1 |
|
medium |
2 |
0 |
2.9 |
|
large |
2 |
0 |
6.4 |
|
extra large |
4 |
0 |
13 |
|
GPU extra large |
4 |
1 |
13 |
The default profile for Native Applications is edge.small
. A Native Application
can also specify a recommended profile.
Native Application Architecture#
Native Applications typically consist of a backend API and a frontend client.
The backend is also responsible for serving the frontend files for a browser to
render the frontend. When a user launches an instance of the application Edge will
provide routing to the backend through Edge's domain edge.enthought.com
.
The Edge Native App Example performs face detection image processing on any images that are submitted via drag and drop. Native Applications should perform long running compute tasks in a non-blocking fashion using subprocesses.
The backend receives new images from the frontend via
POST
operationLong running tasks are started in sub-processes using Python's
multiprocessing
library, and a task ID is returned to the frontendResults are stored in a shared dictionary
The frontend periodically queries the backend for the result of any operations.
Native Application Requirements#
There are several requirements for the application to provide long running background computation and to work with Edge's Authentication system and routing. We will use the Edge Native App Example as a reference for how these requirements can be implemented. This example application uses Flask as a backend and React as a frontend.
Environment Variables#
Edge provides several environment variables to Native Application instances. These environment variables are required for configuring application routing and integrating with Edge's authentication system.
Automatic Authentication#
Edge handles all of the details of logging a user in. The Native Application only needs to define decorators for checking a user's login state with Edge and define an endpoint for handling Edge's authentication callback. For more details, see the README.md in the Native Application Example GitHub Repository.
Activity Tracking#
Edge automatically terminates Native Application instances that are idle. The application
backend should periodically report activity to Edge by performing a POST
operation.
In the example application, this is done using a
track_activity decorator.
Application Routing#
Edge creates a unique path for each user's Native Application instances. This path is provided to the Native Application instance via environment variables, and a user will be redirected to this path on Edge's web domain. For details of how to configure routing, see the README in the Native Application Example GitHub Repository.
Publishing a Native Application#
Native Applications can be published by pushing the application's Docker image to
a Docker image repository and registering the application on Edge.
It is recommended that quay.io
be used as a Docker image repository host.
To publish a Native Application, you will need the following:
A provisioned Docker image repository, such as a repository on
quay.io
A deployment username and password for the Docker image repository
A built container that has been pushed to the Docker image repository
The instructions for Publishing an Application are designed
for publishing a Native Application. When registering the AppVersion
, you must specify
that the version type is AppKindEnum.Native
and provide the address of the Docker image
repository. In addition, you must register a ServerInfo
object with the Application
that provides the registry domain, username and password for pulling the Docker image.