Changes to Be Aware Of
Ignition 8 has many additional changes and improvements that system administrators should be aware of. Although none of them present a significant issue, some may directly affect end users (for example, launching clients), and some can be leveraged to improve the security and performance of your system.
Third-Party Modules
Please consult individual module authors concerning upgraded module availability. Modules built for Ignition 7 will not work in Ignition 8 without modification.
Tag Historian Licensing
See the Tag History Licensing changes under the Upgrading from 8.0 to 8.1 section.
Default Security Certificate
Ignition installations no long come with initial security certificates.
Native Client Launchers Replaced
The Native Client Launcher has been replaced by the Designer Launcher and Vision Client Launcher, which offer similar functionality. Due to the aforementioned "Default Security Certificate" change, secure connections between the launchers and Gateway will require valid certificates are in place.
Introducing Ignition Perspective
Ignition Perspective is an entirely new visualization system, built from the ground up to allow you to create modern, high performance, and highly functional pure-web applications that can be viewed anywhere. Learn more about Perspective by visiting the Perspective pages in the User Manual, or the Inductive University.
Using Perspective without Upgrading
The Ignition Perspective module is one of the most exciting new features of Ignition 8, offering an entirely new and innovative way to visualize data and deploy applications to mobile devices. Many users will want to begin leveraging this module right away, and will feel compelled to upgrade for that purpose.
It is important to understand how various Ignition features, in particular the Gateway network and remote services, can be leveraged to allow immediate usage of Ignition Perspective without the potential risk or disruption necessary to upgrade a running production Gateway.
As part of the base platform, the Gateway Network allows you to create connections between Gateways, including between 8 and 7. The Remote Tag Provider allows you to use Tags from one Gateway on another, including both realtime and historical values. Remote Tag Providers created in Ignition 8 targeting Ignition 7 Gateways will support reading, writing, real-time subscriptions, and Tag history queries. You cannot edit or modify the Tags.
Therefore, to develop and deploy Perspective applications with minimum impact on your production system you can:
Install Ignition 8 onto a different computer or VM instance.
Limit the installation to the Perspective module (though, of course, other modules can be used).
Create a Gateway network connection between the Ignition 8 Gateway and the Ignition 7 Gateway.
Create a Remote Tag Provider on the Ignition 8 system for each provider you’d like to access.
Unless previously changed, remember that the Ignition 7 Gateway will employ the default “service security” settings for the remote Tag Gateway network service. This will allow read only data, but if you want to support writes, you’ll need to change the policy by going to Configure>Security/Service Security in the Gateway.
Introducing Identity Providers
Ignition 8 adds support for connecting to SAML and OpenID Connect Identity Providers. In addition, Ignition can act as an Identity Provider, using a User Source as a backing source of users. On upgrade, a new Ignition Identity Provider will be created that points to a single user source, allowing users in that user source to authenticate against the Identity Provider. You can learn more about this on the Configuring Identity Providers page.
For more information, see the Gateway Authentication with Identity Providers under the Upgrading from 8.0 to 8.1 section.
System Commissioning
Upon installing Ignition, the user is now presented with a “system commissioning” web based walkthrough. This process must be completed for new installations, and requires that an initial user is created for the newly commissioned Gateway.
As of Ignition 8.0, there is no longer a pre-defined default “admin” user. System administrators should choose a secure root username and password for optimal system security.
Security Levels
Ignition 8 introduces the concept of Security Levels, which are abstracted attributes that can be given to users, and used as a means to restrict access to different parts of the system. Security Levels can be assigned to users based on User Roles, Security Zones, a combination of both, or neither, as the Expression Language can be used to determine which level any given user falls under.
Many subsystems in Ignition will automatically migrate over to security levels upon upgrade, such as Tag read and write permissions.
Expanded Auditing Scope
Ignition's built-in auditing system was very limited in version 7, recording only a handful of events. Most events that registered in the system had to originate from a project, so changes made at the Gateway level were largely ignored, save for Tag writes.
In Ignition 8, the auditing system's reach has broadened greatly. The system now accounts for configuration changes made at the Gateway level. Check out the Auditing Actions Reference page for a full listing of actions that are audited.
Java Web Start Discontinued
Support for Java Web Start has been discontinued by Oracle and the OpenJDK community as of Java 11. This technology has been used in Ignition since its original release to launch the Designer and Vision clients, though we have also offered alternative launching tools for years.
In anticipation of this change, the designer and client launching tools have been greatly improved in Ignition 8. In addition to a fresh and more functional UI, the launch tools now manage the Java runtime environment used by the client (see next point), and can help you track many projects and Gateways. There are separate launchers for Vision Clients and the Designer, representing the natural distinction between the target users of these products, and the launchers can be downloaded for Windows, Mac, and Linux directly from the Gateway homepage.
Java Web Start is no longer supported, please use the Designer and Client launchers to launch those applications.
Embedded Java
Ignition no longer requires Java to be installed on the Gateway or client machines. Native versions of the Ignition installer and launchers have been made available for 64-bit Windows, Mac, and Linux, as well as ARM, for use in edge devices. These distributions include embedded JREs (Java Runtime Environment) that are provided by Inductive Automation and managed by Ignition.
The native client launchers manage retrieving the current version of the JRE as necessary for the client and designer runtimes. Updates to the embedded JREs are managed by Inductive Automation and are made available through updates to Ignition. The client launchers will automatically update their local versions as necessary, ensuring that Vision Clients and the Designer are always running the latest version available on the Gateway.
Ignition no longer requires Java to be installed on server or client machines. System administrators should monitor Inductive Automation for important system and security updates, and can sign up for important notifications at http://support.inductiveautomation.com
Project Inheritance & “Global” Upgrade Logic
The project system in Ignition 8 has been improved and now features a more flexible inheritance model. Each project may have a “parent” project, and will inherit all of the resources of that parent project. That project may in turn have its own parent project, and so in this way complex hierarchies of re-usable resources may be designed. Within each project, inherited resources may be used by other, “local” resources. For example, an inherited Vision template could be embedded in a window, or an inherited script could be executed by a button. Inherited resources may also be overridden, allowing them to be re-defined when needed. Conversely, resources in parent projects may be marked as “not overridable” to ensure that children cannot alter them, when appropriate.
This new inheritance system makes Ignition 7’s “global” project concept obsolete. In order to maintain backwards compatibility, the following will happen when an Ignition 7 Gateway is upgraded to Ignition 8:
The resources from the Ignition 7 special “[global]” project will be copied into an Ignition 8 standard, inheritable project called “global”.
All other projects will have their parent project set to this new “global” project.
All “shared” scripts are now simply project-level scripts in a top-level script package called “shared”, stored in the new “global” project. This allows all existing scripts to function without edits.
All “project” scripts are now simply project-level scripts in a top-level script package called “project”.
All Vision templates stored in the old global area are moved into a folder called “SharedTemplates/” in the new global project. The Vision module will automatically convert a template path like “[shared]MyTemplate” as “SharedTemplates/MyTemplate” so that no further action is needed.
If any run-always sequential function charts are present in the global area, a new project called “run-always-charts” will automatically be created upon upgrade, and these charts will be moved into this project. This is because resource types that execute automatically like run always SFCs and Transaction Groups do not run in inheritable projects.
If any alarm pipelines exist, a project called “alarm-pipelines” will be created and all alarm pipelines will be moved into this project. Tags can target pipelines in any project, but in the absence of a specific project, the pipeline is assumed to be in this special upgrade project.
There is a new Gateway-wide setting called “Gateway Scripting Project”. This setting lets you specify one project which all scripts that are outside the scope of a project will execute against. For example: Tag Change Scripts and Tag expressions using the runScript expression. On upgrade, this will be set to the new “global” project so that Tag scripts can continue to access shared.* scripting functions.
Project Resource Storage
The new project subsystem in Ignition 8 uses a new file-based storage strategy, instead of the internal-database strategy used in Ignition 7. This has several significant benefits over the previous methodology:
All resources can now be tracked with industry standard source control tools, such as Git. Resources can be tracked individually, and changes to disk caused by source control operations (checkout, pull, etc.) will be applied automatically to the running system.
Project resources can be transferred between systems with simple file system operations. System administrators can use a wide range of tools to synchronize all types of resources between Gateways.
Project backups are simply standard zip files organized in the same way as the file system.
Designer Concurrent Editing and Conflict Resolution
Ignition 8’s Designer uses a new lock-free strategy for handling concurrent editing. We believe that this strategy is significantly more robust and will allow for more designers to work together on projects.
The Ignition 7 locking strategy (besides being frustrating when users would lock resources and then go home for the day!) is incompatible with the new file system storage strategy. Since changes can occur in the file system at any time, it isn’t possible to maintain exclusive edit locks in the Designer.
In Ignition 8, you may open and modify any resource in your project. You will be notified if the system detects that you and another user are both editing the same resource, or if the resource you’re editing has already been modified remotely. If you modify the resource anyway, and someone else has modified it first, this is called a conflict. The system automatically detects conflicts when you try to save. If any are detected, you are given the opportunity to resolve these conflicts by choosing whether to use your changes, accept the changes that happened elsewhere, or cancel your save and figure out what to do in another way.
The Tag system has undergone significant changes in Ignition 8. The majority of these changes should go unnoticed upon upgrade (apart from obvious UI changes), and most systems should immediately benefit from improved performance, faster edits, and expanded functionality. To summarize:
- "Scan Classes" have been renamed to "Tag Groups". Functionally they're identical. Scan Classes on Ignition 7 systems will gracefully migrate to Tag Groups upon upgrade.
- The Tag Editor has been gone through a major UI rework, but remains as easy-to-use as ever.
- Tags are fundamentally defined via JSON structure now. A new right-click menu has been added to the Tag Browser, allowing you to edit the raw JSON of a given Tag. Additionally, Tag exports/import files now support a JSON format.
The Tag system has been redesigned to optimize for UDT oriented design. In Ignition 7, certain aspects of UDT performance led some system designers to favor standard Tags over UDTs for some applications. Such systems should be re-evaluated in Ignition 8, as use of User Defined Types will lead to much more efficient memory usage and lighter weight change processing.
UDT Parameter Usage
As mentioned in the section Changes That Require User Action , the way that Parameter references are applied to Tags has changed. Instead of being replaced in a “pre-compilation” stage of Tag execution, they are now treated as true property references. This means that they can be modified, and those modifications propagate dynamically to referencing properties, causing those to be updated in turn.
An important consequence of these changes is that syntax for parameter references in Expressions has changed in a subtle, but crucial way. In Ignition 7, due to the replacement strategy, the following would have been a valid expression:
“The value of the parameter is: {ParamRef}”
In Ignition 8, this value would no longer be a valid reference. It is counter-intuitive to all other uses of reference in Ignition, and has been replaced with a more familiar syntax:
concat(“The value of the parameter is: “, {ParamRef})
All existing references will be upgraded automatically to the new syntax upon system upgrade. Designers should be aware of this change when creating new Tags.
Script Based Tag Editing
The various scripting functions for editing Tags ( system.tag.editTag
, system.tag.addTag
, etc.)have been deprecated and replaced by system.tag.configure. The previous functions will continue to work, but designers should learn the new function, which is far more intuitive and powerful than the previous functions.
Tags are now defined as JSON objects, which consist of properties, arrays, and sub-objects. The system.tag.configure function can take either a String document definition, or a JSON object that defines one or more Tags. Overrides for UDTs are created by simple redefinition of properties, and complex structures like Event Scripts and Alarm configurations will be merged with inherited definitions.
OPC UA Default Configuration Changes
New installations have some new OPC UA related defaults:
The server binds only to localhost (i.e. no remote connections allowed)
The server uses port 62541 instead of 4096
The server only allows secured connections (SecurityPolicy Basic256Sha256)
The default “loopback” connection is called “Ignition OPC UA Server” (there is no longer a “-” between “OPC” and “UA”)
Upgrades are not affected by these changes; they retain their existing configuration.
OPC UA Discovery with Third-Party Clients
Ignition's OPC UA server disallows anonymous access on new installations, which can make the server endpoint difficult to discover by UA clients. To help with this, Ignition's UA server runs a separate unsecured endpoint to allow discovery. The discovery endpoint is accessible by appending /discovery
to the end of the URL:
opc.tcp://1.2.3.4:62541/discovery
Changes to system.alarm.listPipelines
The listPipelines function was changed to search a single project for pipelines. Upgrading from Ignition 7 to Ignition 8 will migrate all alarm pipelines into a project named "alarm-pipelines". To maintain backwards comparability, system.alarm.listPipelines() will check for a project named "alarm-pipelines", but now accepts a project name as a parameter, allowing the function to check for pipelines in any project.
SQLite Storage
Gateways can now create SQLite databases, or "Internal databases" for many of the storage subsystems (Database Connections, Historian, Alarm Journal, and Auditing), allowing your gateway to store and retrieve data without needing to connect to a remote SQL database, which is useful for development systems and demonstrations.
Note: We still recommend external SQL databases are used in production systems, as they generally offer a level of performance and redundancy not available to SQLite databases.