Connectivity Applications
Tenant administrators install and configure the OLIVE connectivity applications that belong to their tenant. Everything on this page happens inside your tenant and affects only your tenant's users.
The Connectivity Editor
The Connectivity Editor is the main interface for managing connectivity applications within your tenant. Through it you can:
- Instantiate new applications from available templates, to provision capabilities to your users
- View and manage the applications deployed in your tenant
- Export and import an OLIVE Connectivity Bundle (OCB)
Instantiating Applications from Templates
When you want to provide your users with a new connectivity application, you instantiate it from a template.
How Template Provisioning Works
The Templates Configurator shows the scenario templates available in your tenant. These are pre-built connectivity solutions, ready to be deployed.
To create a new application for your users:
- Select a template — browse the available templates in the Templates Configurator
- Configure parameters — provide the tenant-specific configuration through a guided wizard: connection details, credentials, business logic settings
- Instantiate — complete the configuration to create an application instance that is immediately available to your users
Each template is reusable and customizable, so a standard connectivity pattern can be adapted to your organization's needs.
Earlier versions had a shared common assets tenant: a central library of reusable components that every tenant referenced. Provisioning a scenario meant importing it twice — once into the common assets tenant and once into your own.
OLIVE 1.3 has no common assets tenant. Templates and microfrontend components live in the tenant that uses them, and an import goes into that tenant only. If a scenario should be available in several tenants, it is imported into each of them.
Managing Deployed Applications
The Application Workbench gives an operational view of the applications instantiated in your tenant:
- Search and discovery — locate applications by name or other attributes
- Open applications — open an application's interface directly from the workbench, where the underlying scenario supports it
- Access underlying data — inspect the data connectivity instances an application references, to understand its structure and configuration
Export and Import
Export and import move connectivity content in and out of your tenant as an OLIVE Connectivity Bundle (OCB) — a ZIP package containing the connectivity elements (datapoints, connectors, authentication entries, templates and presets), the microfrontend components, and a manifest recording when the export was made and with which export version.
An OCB is used for more than backup:
- Promotion — build a solution in a development deployment, export it, and import it into production. This is the intended delivery path for connectivity work.
- Backup — keep a snapshot of your tenant's configuration outside the platform.
- Transfer — move validated content between OLIVE installations or environments.
Both operations run in the Connectivity Editor.
Authentication entries — OIDC, OAuth2, basic auth — travel inside the bundle. Unless the export is encrypted with a password, they are in plain text. Store bundles accordingly, and rotate any credential that has travelled in an unencrypted bundle. Rotating connectivity credentials is done in the editor; see Secrets Rotation for the wider picture.
In a production deployment, only a user with the admin role can import. Editors can create and change connectivity, but not import a bundle. A development deployment has no authentication and a single user who holds every role, so the distinction is not visible there.
Name collisions
When imported content collides with content already in the tenant, the importer is shown an overview of the collisions and decides how to proceed: overwrite everything, or keep what is already there and ignore the colliding incoming elements.
When connectivity needs to reach an internal address
From OLIVE 1.3 the platform refuses outbound calls to internal destinations — private address ranges, Kubernetes-internal service names and cloud metadata addresses — and records the attempt as OLIFETCH1. Calls to public destinations are unaffected. This is not configurable from a datapoint, a connector or a template.
Connectivity engineers are told to bring such a case to you, so the request will arrive as "this datapoint worked in development and is refused in production". The commonest version is a service the organization hosts in the same cluster.
What to do with it:
- Check first whether the system can be reached as an ordinary external endpoint. That is the answer in most cases and needs nothing from anyone.
- If it genuinely cannot, collect the details — which system, why it cannot be exposed externally, and what the connectivity is meant to do — and pass them to your platform administrator. Only they can register an internal destination with the platform, and they raise it with OLIVE support.
There is no public API for this and the mechanism may change in a future release, which is why it is not documented as a pattern. A reported case is also what decides whether it becomes a supported feature — a workaround built quietly around the guard is not.
What you do not own
Deploying the platform, creating or removing tenants, cluster and storage operations, and the platform-wide security configuration belong to the platform administrator and the operator — see Platform Administrators and Operators.