New Features of Ignition 8.3 with Travis Cox (S2E37)

Episode Transcript
Available transcripts are automatically generated. Complete accuracy is not guaranteed.
(00:00):
Hey, everybody. Thank you for tuning back in
to the Automation Show. My name is Sean
Tanny from Insights.
And in this episode, I actually have a
special guest join me, Travis Cox from Inductive
Automation to tell us all about Ignition 8.3.
He's gonna run through the new features, and
he's gonna give us a demo. And whether
you're watching or listening, I think you're gonna
find this very interesting. And I really appreciate

(00:22):
Travis coming on, and I appreciate Inductive Automation
sponsoring this episode so I could bring it
to you completely ad free. So with that
said, let's go ahead and jump into this
week's episode of the automation show and learn
all about Inductive Automation's
Ignition 8.3.
Travis, welcome to the show. I'm excited to
learn today about what's new in Ignition 8.3.

(00:44):
And, but before we jump into that, I
was hoping we you could, take a moment
and introduce yourself to our audience.
Yeah. Thanks, Sean, for having me. So, my
name is Travis Cox. I'm the chief technology
evangelist here in Ductspot Automation.
I just tell people I speak the gospel
of Ignition. That's what I do. I've been
with the company for almost twenty two years.
I I was the the third employee there,

(01:05):
and I've always sat more on the technical
side, helping customers, you know, with their architectures,
applying best practices, filling figuring out how to
to integrate solutions,
figure out how to really leverage, you know,
Ignition and to to kinda get to the
art of the possible.
So I'm really excited to be here with
you and to share Ignition 8.3. It's exciting
release.
Yeah. I'm excited too to see what's new

(01:26):
in it because I I I love following
your updates. You guys do a great job
even on the minor points,
keeping your, your customers up to speed on
what's going on. And I really felt just
from reading the updates, like, you're really doing
a good job trying to incorporate
requests from the customer
into your product, which is always very much
appreciated. So, let me turn it back to
you. Let's learn what's new. Alright. Yeah. So

(01:48):
we're gonna do a guided tour through Ignition
8.3.
It's a big release. There's so many new
features in there. So we're gonna we're get
the big hitting ones. You know, there's many
other smaller ones, but,
here we'll give you a a good tour
and we'll kinda show those in act live
in action and give you a good sense
of of what that has to offer.
So
let's start

(02:09):
with just a little bit information about 8.3.
We released it on September 16, this year.
This is a couple months ago. We leased
it at our conference, ICC conference,
and this has been a release that's been,
you know, going on for a couple years,
and it's it's it's a comprehensive update to
the Ignition platform.
There's a lot of things that we've,

(02:29):
we had, you know, we've we've seen our
vision that we wanted to have for Ignition,
and this release really,
took a little while, but we actually are
able to realize, that vision. And really it's
to to bring the worlds of OT and
IT together,
so that we can obviously leverage the best
that OT has, but also leverage the best
that IT has and bring in the latest
and greatest technologies into the OT landscape.

(02:51):
I think it's a really important thing to
be able to do for how people want
to deploy systems, manage these systems, the types
of things they're trying to connect to.
So we really wanted to design this this
version to be the the world's most powerful,
open, and flexible application development platform.
So
the the big focus on this release is
to unlock data's full potential. We've added more

(03:12):
connectors,
especially drivers to PLCs.
We've added connectors things like Kafka
and, ways to be able to move data
around in some unique ways that we'll show
here today.
We've also simplified project workflow, so people that
are building HMI and SCADA applications with our
perspective module.
There's drawing tools, there's new form components, there's

(03:34):
just easier ways,
to build those applications to get that to
where you want it to go.
And a big focus of this release is
how to manage and configure the systems with
ease and that now people are deploying lots
of systems out there, especially at the edge,
and you have lots of them. You wanna
be able to to manage them, make that
part easier,
and also to leverage kind of the best

(03:54):
in class, you know, tools out there for
things like version control and DevOps,
which we'll go through and show today.
And it's all about deploying and securing these
large systems
and how we can, you know, make that
as efficient as possible and handle, you know,
millions of data points that are out there.
And there's a lot of enhancements to
optimizations
and security in this release that, that aid

(04:16):
in those larger scale out systems.
And of course this is an LTS release,
so it means long term support, which means
that it's supported for five years.
So, we're gonna continue adding critical fixes and
minor features to this release as we go
along and, they get that peace of mind,
you know, that this is gonna be, stable
and will be supported,
for that term for that that duration there.

(04:39):
So that's a little bit about Ignition 8.3.
What we really wanna do is go and
see these features in action. So here's here's
what we're gonna take a look at today.
We're gonna look at the new redesigned Ignition
gateway, the the web UI,
and, it's a better UI UX experience. We're
gonna show what that has to offer. We'll
look at our new historian,
especially with our embedded historians built into Ignition

(05:01):
based on the QuestDB.
We'll take a look at perspective,
and, that's that's the native HTML five visualization
and the drawing tools and the offline forms
that are part of that. We'll show a
small but mighty feature called Alarm Metrics, and
we'll look at Event Streams. This is a
brand new module. This is a low code,
no code way of moving data around,
with the Kafka connector that we have with

(05:23):
that.
And then we'll end up with some DevOps.
We'll show version control, the new rest API,
and this exciting feature called deployment modes that
allows you to have, environment separation.
So that's kind of the goal here for
today and,
you know, Sean, if you have you wanna
dive in any point, have any questions, you
know, feel free.
You know, so we're gonna we're gonna hit

(05:44):
hit all these features and give you a
good sense of how they work.
Let's start with the new redesigned Ignition Gateway
webpage. So I have Ignition
installed on my local machine here. Of course,
it is super easy to go website, and
you can go to the downloads page of
the website,
and there you can, download Ignition for your
operating system.
There's Windows, Linux, and Mac installers. There's also

(06:06):
a Docker image. You can go and deploy
that super easily.
We also have, some Helm charts that you
could deploy through Kubernetes. There's a lot of
options for how to get Ignition out there
and it runs in a two hour trial
period. So you can everything I'm gonna show
you today, you can go and play with
and at the end of two hours, you
just press the reset button, you try again
for another two hours. So you can fully
evaluate every part of Ignition in that way.

(06:28):
So here is my, Ignition 8.3 on my
local machine. This is the new web UI
and for those of you who are brand
new to Ignition, if you install eight point
eight point three, it's gonna be very intuitive
and easy to start with. People that are
familiar with the older release, Ignition 8.1 and
before, it's gonna be a little bit different.
But the idea was to guide you to
places very quickly
and to combine the idea of status and

(06:49):
configuration in one view.
So if I'm not logged in, all I
can do is be able to go and
see,
what this server is and be able to
launch those applications that were built out as
well as launch the designer. But as soon
as we go ahead and log in, this
is where we can actually go and modify
the config.
And we have a couple different areas. We
have our platform area, which is all the

(07:10):
configuration
for the the Ignition platform as at the
top level, especially security.
There's connections to things like MQTT
and Kafka and databases and devices.
There's network where we can get to the
gateway network and our enterprise administration module and
configuring the web server. There's services for things
like our story and our tag system, our

(07:30):
alarming system, all the information about those services
as well as, of course, diagnostics to see
how Ignition's performing,
get a quick glance at all of that.
So if if I look at the platform,
one of my favorite features of this web
UI is this overview page right here because
it gives all the config at a glance.
I can see everything that's happening, what's configured,
and what's possibly going wrong all in one

(07:50):
view. And so you can see here I've
actually got a database connection
that has an error. So if I expand
that, there's my local database. It's faulted. Looks
like I have an access denied. I can
go straight over to that area and I
can get more details on the error message.
Of course, I can then just go ahead
and and I have the wrong password here.
So I'm gonna go ahead and update that
password
in this config,

(08:11):
save those changes, and now it's valid, ready
to go. With that, go back up here
to my platform overview. I can see that
that issue is taken care of and this
one's okay, but really easy to see that
that information at a glance.
Also, if you didn't know where something's at,
you can go up here and just, like,
go search. Let's go device connections or devices
and go right to it. I can see
the devices that are configured. So it's a

(08:31):
really quick way to see what's going on
and to to see the status of config
all in that one view. So we really
think this is gonna be a much easier
way to to manage all those connections and
to manage all that configuration,
very quickly.
So that's a a very important feature is,
we always wanna make the UI UX experience
much better for Ignition people when they're in
the gateway configuration as well as in the

(08:52):
designer for Ignition.
The next feature we're gonna look at is
the industrial historian solution suite. So we've always
had, Historian built into Ignition. If I go
to my, services down here, this is where
I go to my Historians,
and we could we've always been able to
connect to SQL databases.
So with that with that, we can log
data to MySQL, Microsoft SQL Server, Postgres,

(09:14):
you name it. And a lot of people
are using Postgres with a time scale extension,
which is the time series database extension to
that. So kind of combining relational and time
series together.
So we still have that, of course, with
Ignition 8.3,
but now we've introduced a brand new core
Historian. And this is a built in Historian.
It's kind of it's built into Ignition. It's
it comes with it out of the box.

(09:36):
It's embedded inside of Ignition,
but it is not proprietary. It is based
on open source technology.
It's based on QuestDB.
It's a very popular time series database.
It's very performant and we've been able to
do benchmarking with bringing millions of data points
and and be able to not affect the
query speed to be able to bring that
data back. So we think this is perfect
for brand new users who are coming in,

(09:58):
they can install Ignition and they can have
a greater story and built in. They can
log data for a couple years, no problem.
And, a lot of people are then looking
at what's my final resting place. Am I
going to the cloud or going to a
corporate data center? What are we doing with
that? But this is a great way to
start. All you gotta do is simply create
one. I'm gonna call it local historian.
And, we can go down here and specify

(10:20):
pruning, which you can delete old data or
archiving where we can archive data into,
a folder after some time period and, that's
it. I'll create the historian. Now I have
it ready to go. Of course, we can
go to our designer. I can go to
any tag I have in the system. So
I'm gonna go to these realistic tags, right
click edit,
come down here, turn on the historian, go

(10:41):
to that local historian here. That's it. Press
okay. All the data is now being logged
directly in that embedded,
time series database.
And it's super easy from that point. I
can go over here to my charts. I
can expand. I could see those tags are
logged. Bring it on. Boom. I can see
the data coming in very quickly.
So very, very fast way to get started
with the historian.

(11:02):
All that data, of course, is easily to
get out of Ignition,
you know, from there.
And, just just to mention, we have an
SDK. It is possible to actually extend this
list of Historians, these engines, with your own
if you wanted to. We have a great
API,
that allows anybody to extend. So we've actually
had some some partners,
who've created extend extensions to to their storage

(11:25):
formats.
Most notably is, Flow software with Timebase. They've
been able to build that as a module.
So lots of cool stuff that's possible with
this new historian area. That looked like it
was really easy to do. It seemed like,
and correct me if I'm wrong, the goal
of doing that core historian
was, as you just showed,
to be able to set up your historian

(11:47):
in under a minute. Whereas if I was
going to SQL Server, install SQL is it's
a whole other thing I have to go
through. And so
was was that what it was? I mean,
did you just want people to be get
it be able to get it and start
collecting data right away without having or forcing
them to really, like, install a SQL Server
or MySQL or something else?

(12:07):
Yeah. Exactly. I mean, SQL database has been
great. And from the very beginning of this
company, we've logged data to a database. You
know, we have that bridge between OPC server
and a SQL database. Yeah. But that requires
people to install database and to also then
manage it. While a lot of IT departments
are doing that for for the the OT
side, some companies don't have, you know, IT
department who can manage that. And so it

(12:29):
it's an expertise level that some people just,
you know, they that they just don't don't
have. Whereas with this, they don't have to
worry about any of that. It all comes
in. There's not installing any anything outside of
Ignition and is based on, you know, modern
technology that is very performant and, gives you
a lot of power. So absolutely. Wanna we
wanna make that that journey to Ignition, especially

(12:50):
for the new people, really simple.
Yeah. That was that was simple. I love
the workflow there, how you went through that.
And, you had a trend going, a historical
trend going in no time. I think you
did the whole thing in under a minute,
which was impressive. So let me turn it
back to you. Yeah. Absolutely. And that's that's
the goal. We wanna we we our our
motto is kinda first make it possible and
then make it really easy and that's, that's

(13:11):
what we've done here with the historian for
sure.
And that's, goes to our next area which
is our drawing, tools and our application editor,
and the the forms to be able to
build forms and and and to have offline
forms. And I'll show you what that looks
like here.
So let's start with the drawing tools. You
know, we've have a visualization system called perspective

(13:32):
and that's where you're and you saw me
kind of in there already where I with
this trend. This is where we can build,
you know, screens and build the applications that
we have. And, we've had, you know, various
symbols in inside of Ignition
like, you know, motors and pumps, and we
have a lot of, SVGs that, come with
the simple factory graphics.
But a lot of people want to be

(13:53):
able to edit SPGs inside of our designer
as well as to be able to create
ones from scratch. And that's what we've added
here, in 8.3 with perspective. I can go
over here to our drawing component, drag it
on the screen, and I can go in
here and simply let's say, I wanna make
this a 100 by a 100.
I can go in and let's say I
just wanna undo something as simple as drawing
a circle. I know it's not very exciting,

(14:15):
but for people who have been editing a
perspective before 08/2003, it was not as easy
to draw a circle as it is now,
with these drawing tools. And so with that
I can go over, I can change the
color of this,
you know,
let's go here make it, make it red.
And so super easy to make that press
apply. Now I have an SVG. This is
a simple SVG, but I've got an SVG.

(14:37):
And there's lots of graphics that way. I
can go up here to our symbol factories
is what we've had in there. So, for
example, I take this motor. I could take
the motor in here, and I can then
go edit it. Let's say, you know, I
didn't like this circle up here. I wanna
get rid of that,
and or I want to bind or link
this square to the color,
you know, to the the the PLC and

(14:58):
change the color. Well, we can do that
really easily. So here's my SVG. It can
take the square. I click on the the
bind next to the fill. I can link
that to a tag. Let's say, we go
over here to our writable integer one tag,
and, I'll do a little map that says
if the value is zero one two, we're
gonna go to a color, and zero, I'll

(15:19):
make it red, one, I'll make it green,
kind of the classic sense here.
Let me do two and press okay. So
now I've got the binding on there and
press apply and now I've got an SVG
that I've edited. I can also, of course,
change that shape or modify all within that
drawing editor very quickly
and, at this point if I if the
value changes, let's go down here and make

(15:40):
this set to a one.
You can see it's green. Right? Simple as
that, in turn being able to do it.
Now another part that's really, I think, important
is that if I can make this let's
go,
80 pixels tall. I can actually add text
right inside here.
So let's say I make this, you know,
motor one
and this is SVG text and the reason

(16:01):
that's important is that that automatically scales. So
if you've got a HMI screen where you've
got a bunch of text on there, you
can have that combined with the SVGs, and,
really, it makes that a lot easier,
for the scaling, for what you're trying to
accomplish there.
So you have an s SVG editor inside
of your application.
And when you open it up, to me,

(16:22):
it kinda reminds me of Paint. Right? So
everybody's familiar with Windows Paint,
but on steroids.
And you're even editing your symbol factory graphics
in there and adding animation
in the editor, tying the the property, like,
the color property of a tag or or
the color property of an a part of
an object
to a tag all with inside

(16:43):
that editor.
And by adding the text in there, now
you have scalable vector graphics,
you know, the features of scalable vector graphics
with the text so that no matter what
size you make it, it's not hunting for
a font size. It's actually
scaling like you'd want it to scale,
and maintaining that that perspective. I mean, that's
that's impressive. And so the new thing here

(17:05):
is it's a new interface, easy to use,
flow as far as,
using the editing. It it sound like you
did have this feature in before, but you've
updated it. Am I correct? So we actually
didn't have the drawing editor at all. I
mean, for s p g's you can you
can bring the s p g's in but
what it looked like
was, essentially an s p g with all
these elements over here and you're like, what

(17:28):
is this path?
Oh. Yep. And and it was very hard.
So obviously, if you wanna edit it, it
makes that difficult.
If you wanted to bind binding is the
is the the combination of the the editor
with the binding is really powerful and nobody
has to go outside in a third party
SVG editor and then use that and then
bring it back.
That's cool. So it's really nice. And then,
of course, you can also take an SVG

(17:49):
that you have outside of Ignition. I can
drag it in. So I've got this is
our logo. I'm bringing it in and embedding
it. So there we go.
And of course, I can go in real
quick. If If I have one, I wanna
make some changes. I wanna remove these the
text down here. Boom. Boom. And I've got
that logo and that was just really easy
to make those quick modifications. When you're building
these kind of screens,

(18:09):
it's really nice to have that editor just
to go quick. You know, nobody wants to
have to worry with multiple tools. Right? Just
wanna do it all right there in the
designer.
Yeah. Absolutely. Absolutely. That's amazing. I love it.
Along with that, another thing people have been
trying to do, of course, when you're building
applications, you're not just building HMI SCADA screens,
you're also building forms. You know, people entering

(18:30):
in data manually.
And, you know, you were doing that before
by adding in text fields on the screens.
Right? Or adding buttons on there to save,
and labels, and and drop down lists, and
all these individual components. That's great, but that
can be time consuming in building out the
form.
And so what we have now
is a new component in perspective for forms,

(18:52):
and and a couple different examples. But if
I drag this on here, it's one component
where I can define the entirety of the
form, all the form fields, the validation,
and it does all the submission and all
that for you.
And the the biggest reason is so that
we can make it easier to build forms,
and it can also have dynamic forms, but
it's to get to a place where we
can have offline forms. This is where I'm

(19:13):
gonna where I'm gonna lead to end with.
So that this first component here allows me
to go in. I can simply say, you
know what? Let's go down here to here's
our text widget,
and let's say I want this label to
be first name. Right? So you change that
first name. Here's the text and text. I
want that validation
here to, I'm gonna do a required field.

(19:36):
So it's a required field. It means if
I'm in the run time and I go
next, it's gonna say, hey, no. You gotta
fill this field. It's all done for you,
all built in
and there's all sorts of different widgets. So
let's say I wanna do another one and
this widget's gonna be a, you know, password
or URL or drop down or checkbox or
any of these things. So I can do
a drop down and in the drop down

(19:57):
I could specify multiple options.
So let's do option one
and then I'll do another one here,
option two.
And, this seems a little bit like there's
a lot of config over here. We're gonna
be adding an editor to this to make
it easier for that. But what's important is

(20:17):
that I can actually bind this whole thing
to a query or something and make this
dynamic, which is really powerful to be able
to do. So you can see I can
really build out these forms pretty quick. And,
I've got a form already built out. So
this one here, this machine safety inspection checklist.
And this one, I am, when it's submitting,
it's firing a submission event and we're actually

(20:38):
handling that,
this inspection,
so that it can actually log to a
database very easily. And And whether I'm doing
it from the browser or if I'm doing
it from my native app, it's gonna be
able to guarantee that when they when they
submit it that it's gonna get there. It's
gonna be stored.
And so I can easily then let's go
launch let's go launch this client.

(20:59):
Here, I'm in my browser. Let's go and
say compressor
one. I'm doing inspection. This is Travis doing
it,
and I'm gonna check these boxes.
There
was a problem.
So we do that, submit it, and that
form was was submitted. Now if I go
to my database, I can look at my
inspection form and there sure enough, there's a

(21:20):
record in there for that inspection.
But what's really cool here,
is I'm gonna show you now the native
app,
because this is where it gets real powerful
especially
for being offline. So let me mirror my
phone.
Alright. So I'm gonna add this application to
my phone. So I'm gonna go down to
my Ignition server.

(21:42):
There we go. This one. Here's my demo
application. So let's edit that one. I'm gonna
make it available offline. So you can see
right now it's downloading it top left,
and, I'm not offline right now, but if
I go in, I can use that form.
That's that's great. I can enter the data.
But let's say I was offline.
So for the sake of this, what I'm
gonna do real quick
is I'm just gonna,

(22:03):
stop Ignition for a moment,
since I'm all on the same machine.
And I'm gonna it's gonna make this thing
go offline.
So we're gonna mirror my phone again and
you're gonna see what this looks like an
offline
way. Alright. So let's go back in there.
Of course, it's gonna it's not gonna be
able to connect to the gateway. It's gonna
be, hey. You know, I'm I'm disconnected,
and, it's still gonna run, still gonna work.
So if I'm not if I'm out there,

(22:25):
no Wi Fi, no cellular,
I can still go in and, let's say,
pump. We're gonna do
pump, one,
and this is me doing it,
and here we go. Let's go and just
everything everything looks good. Submit that, and here,
what's happening, you see it's added to the
offline queue.
So if I go and look, there's a

(22:45):
queue, submission queue, and when I get back
in range, this data will automatically happen. So
let's let's bring Ignition back up, and we're
gonna see this data automatically
getting come come back into Ignition. And this
is what's really powerful is to be able
to I can still have this application work
even though I'm offline.
So here, it's almost ready. There it goes.

(23:07):
It was,
brought back up. Let's go in here, refresh,
and now
there's my pump. It got it got added
to the database.
So a really powerful feature to be able
to build these forms, especially to have these
forms available offline when I'm not connected to
that server no matter where I happen to
be,
to be able to to do these, different

(23:28):
things. And we're gonna be adding here just
shortly. We're gonna add a a signature field
and the ability to take pictures from your
phone and and add in the form.
Now on on the phone, were you use
using a web browser or is it the
Ignition app? I was using the Perspective native
app on iOS and Android that's available in
the stores. It's free.
And that is what when you sort it's

(23:50):
it's stored in that app. It's stored in
that queue in that app. Perfect. And then
when when I'm back in range, it just
automatically sends those back to the gateway.
So that way everything is is good to
go. It does we wouldn't have that functionality
directly in a browser. So that's why we
have to have the native app on on
those devices.
Well, that's why I was asking. And I,
you know, I think it's a good, you
know, you know, standard operating procedure. If you're

(24:11):
gonna go out and fill in all these
new offline forms now where you may not
have any Wi Fi or any Internet,
you can come back in, open the app
back up, and make sure it synchronizes.
Yeah. I think we're a lot of us
are used to that operating procedure with, like,
you know, phones or videos or anything we
do with our phone where it's cached, and
we gotta come back in and synchronize it.

(24:31):
I know I do it a lot when
I'm at a trade show taking pictures. I
gotta get back on the Wi Fi and
sync them all up to the server.
So, no. That makes a lot of sense
in it. Very straightforward. And I noticed today,
you're editing this all using the property panel
on the right hand side. You're duplicating. You're
editing. You're changing the the type of fields,
you're changing their text, the titles, the the

(24:51):
format, whether they're required or not. But did
you say that in the future, you're gonna
pull an editor in right on the form
itself?
Yeah. We're gonna do, an editor like like
with the SVG when you pop up that
box and be able to change it. We're
gonna do one for the forms. It's a
obvious place to do it. We want to
get this feature out and have people to
be able to take advantage of it. But,
yeah, we're gonna make it so it's easier
to build that for, you know, new people.

(25:13):
They're not they're not having to right click
and duplicate and change all these properties. It
it is a pretty deep property structure here.
And we did that for to make it
dynamic,
but we're gonna make come back around. Again,
make it possible, then make it easy. That's
kind of the the goal always.
Awesome. Looks great.
Cool. Well, let's let's move on to, our
next, we have we have three more features

(25:34):
to show out, show off here. The next
one's Alarm Metrics. This is a very simple
one, a small but but mighty feature.
So here, for example,
if I look at my writable, I've got
a couple alarms, this buoy and this integer.
And so if I make this boolean go
true right now, it'd be active.
And,
you know, individually, I can look at the
alarms, see if they're active. I can look

(25:55):
at the alarm status component and see what's
happening. But sometimes you wanna be able to
know if there's any alarms that are active
within a folder and below. And so we've
now added this alarm metrics metadata to every
folder. Every folder can can use it where
I can see if anything inside is active
or what state the alarms are in within
with with that folder and below. Same thing
for a UDT instance,

(26:16):
and again, it could be as as throughout
the entire hierarchy, you can use that and
I can simply just bind,
you know, something on the screen to that
any of these properties. Like, I could bind
the circle to the has active and if
it's active, I can make it red. So
very, very easy. Again, small and mighty feature.
Nobody has to worry about figuring out, you
know, that. We just give you the data

(26:36):
right there in the in the tag,
database
so you can just use it directly.
So for people who have been wanting this
for a while, it's kind of a pain
to do it yourself. So with this, it
just
it just it's right there. Right? You just
can use it.
So that's a small but mighty one. I
always love bringing that in there because it's,
you know, not every improvement is major. Right?

(26:56):
Some of them are little things that really
make a big impact.
The next one is a huge,
a new module that's a really, really powerful
module called Event Streams.
And what I wanna do
is I wanted to take a moment just
to kinda talk about this, and then I'll
show the demo. Event Streams is a way
to move data between different sources and destinations.

(27:17):
And we've always been able to do that
in Ignition, but we've been pretty prescriptive about
it. You know, for example, I wanna take
tag data and write it to MQTT using
Sparkplug
or I wanna log it to a database.
We've had various,
ways you can you can do that and
some people use scripting to go above and
beyond. Well, we didn't want to have people
have to write a lot of code. So
event streams is a way to have a
low code, no code environment to move data

(27:37):
around. And the idea is that you build
these streams, and every stream can have a
source. So I can look for data coming
from a MQTT topic, a Kafka topic. I
look for come from a tag, a message
queuing system, a database. And when that data
comes in, we can then filter it, we
can transform it, we can batch it, and
then we can send it somewhere. And that
could be sending it to another database or

(27:59):
another broker or queue,
or send it to a REST API, whatever
you wanna do. And this is, we're not
being prescriptive at all. You can decide how
you wanna hook up these sources and these
destinations,
through throughout what you're building.
And that's the the power of event streams.
And so let's go over here to our
designer and there's this new area for event
streams. I can break break build a new

(28:20):
stream and let's show Kafka first. So I'm
gonna do Kafka and you see there's different
sources here MQTT,
tags, Kafka, event listeners,
HTTP.
There's multiple different ones. I'm gonna do Kafka
and I'm gonna listen for a particular,
Kafka topic. So I've got actually a a
Kafka connector already, configured. So let me go

(28:41):
over here to my gateway
and log in. I wanna show
under the services,
if I go to connections,
service connectors, there is the ability for you
to create new Kafka connection. We're gonna add
multiple service connectors as we go forward.
So I'm already connected to a local,
broker, and with that I can go and
listen for things to change. So I'm gonna

(29:01):
listen for ignition messages to come in. I'm
gonna call this one ignition
group,
30.
And,
when that data comes in, it's gonna be
a JSON object. I could filter it to
get rid of certain things if I didn't
want the message. I can transform it, manipulate
that message. I can buffer it to make
sure it gets somewhere. And then, of course,
we can handle it. Handling is most important

(29:22):
where I can send it somewhere. Let's say
I wanna log this to a database.
I can go insert it into a table
called
let's go down here to Kafka
messages.
I'll store a timestamp into the timestamp field
and we'll do three,
columns, machine,
status,
and temperature.

(29:42):
And these are a string
a string and a float.
And what I'm gonna do is I'm gonna
grab data from the the payload. So the
first is event dot data dot machine. That's
the machine part of that JSON message. The
second one is a a status part of
the message, and the last one is a
temperature. And this is a this is a

(30:03):
expression ignition, and you could do really whatever
you want. Combine things together,
use our expression functions, all that good stuff.
So now I'm gonna insert this record,
into Kafka from that Kafka message. So go
ahead and save it. You can see that
nothing's coming in yet. No. Nothing's there. I'm
gonna go run a outside program here just
just to be able to send a a

(30:24):
record. So it's gonna say this should send
here's the payload,
two Ignition messages. It did. Here's the one
that came in. It went to the database.
And in fact, if I go to my
database, look at Kafka messages,
boom. There's that record. Quite simple, easy for
that to happen.
And what's great is I can send more
than that more than just that one place.
Let's say I also wanted to log it

(30:45):
to m or send it to MQTT.
Let's send it out there. Let's go to
MQTT Explorer. I'll connect here. So we're gonna
go to database and MQTT at the same
time. So let's go and
send another record. Boom.
Now here's here's event streams. There's that MQTT
stream, another record that came through. And that
went to the database as well. So we

(31:05):
can go and do as much as we
want and we can have lots of sources,
lots of handlers, lots of different places that
we can hook this data up. It's quite
powerful. Last thing I'll show real quick is
let's do a load. Let's send a 100,000
records. Let's watch this thing load up, because
this is where the buffering and all that
importance comes in so that we don't lose

(31:26):
that data, that it gets there. And you're
gonna see that we're handling now we're about
50,000 records we're handling. And in just a
few seconds, we're gonna have all 100,000
records from Kafka going through falling to Kafka,
being logged to a database, and sent to
the MQTT server just like that. And boom,
there we go. We've now handled all of

(31:46):
that data. And so it's a really great
way, really high performing,
easy way to move data around. Nobody's writing
code. We're gonna be able to do this,
by just simply setting up these different streams,
and there's all sorts of different ways that
we can,
different ways that we can do this.
So I'm not gonna show every one of
them, but
kinda get the sense of of just the

(32:06):
the power that could be there. And what's
really cool is that this is also extensible
through the SDK. You can add additional sources.
You can add additional handlers
and as a module, and we, as induct
Adaptive Automation, are planning to add a lot
more.
We we wanna go to Google PubSub and
AWS services, Azure services, all sorts of different
places that we can use that will really

(32:27):
make this even more and more powerful.
Alright. As much as I'd love to show
every feature off of of the event streams,
I could I can do a whole session
just on that module, but it's a really
powerful one for sure.
Let's move on to,
this next one, which is, probably my favorite.
I think this is the the crowd favorite
of Ignition 8.3. Arguably the most important,

(32:49):
feature of this entire release is the version
control, the DevOps version control, REST API, and
deployment modes. So let's go back,
and first and foremost, let's let's kinda talk
about the
the source control.
So I'm gonna bring this over. All of
our configuration in Ignition 8.3 is stored in
the file system as JSON files. There is

(33:11):
no more internal databases. It is all
readable easy JSON files. If I go to
config
and I go to my resources,
my core, if I go down to Ignition,
here's my database connection. There's that local database
connection as JSON. Just simple. It's right there,
on that server, easy to see. If I
look at my tags, so here's my realistic

(33:32):
tags, just done right there.
You know, I see them all all these
all these the configuration. I can make modifications
to that and have that being read into
Ignition, but more importantly, I can have this
committed to a repository.
And that's what I wanna show here real
real briefly.
In that I've got a GitHub,
repository set up, and I want to make

(33:55):
that my data directory,
that. So
let's go over here
and let's get into our data directory
and, I'm just gonna run a couple of
the simple commands. So git init
and then git commit.
So we'll commit our first one.
So we're gonna do that. And then,

(34:17):
last thing I'll do is I'll put it
in that directory.
Alright. So,
if I go add this I I'll use
a tool now so we can actually see
this.
Let's go into here. Perfect.
I'm gonna bring this over. And so here
we go.

(34:38):
So I could see all this stuff. Here's
GitHub Desktop. I could see all these changes.
I can say, you know, here's my initial
commit, and I can commit all these, and
I can push those to that repository
and have everything available.
And,
I'm not gonna show all the different backs
and forths, but if every time I make
a change, I can see those changes that
are happening and that will get brought into

(34:59):
that repository
and that we can use makes it really,
really easy to work with,
and to be able to see and track
those changes over time,
and have that full version control. The other
part that's really powerful is that if I
did want to change something let's open this
in I'm I'm gonna open this in Sublime.
Let's say that I I wanna set this

(35:20):
last,
this this tag realistic seven. I want this
to be called temperature.
Boom. I save that. Now if I pull
from repository, it came back, I can then
go over
to,
my system. I can scan for that change,
and you can see that in my realistic
folder,
it is
now from six or seven to temperature.

(35:43):
So very easy for us to kinda do
that that full version control with the the
files and the file system. So let me
ask you about this. It seems like so
now that Ignition is a 100% JSON,
everything all your all your configuration is stored
in that format.
It sounds like you could use you can
use GitHub like you just showed, but could
you use other DevOps packages as well? I

(36:05):
imagine that go ahead. Yeah. For sure. You
can use whatever you like. I mean, some
people are gonna go to GitHub. Some people
might have GitLab which is like the open
source version on prem or you can use
any real any system that you want. And
or of course, maybe you're not storing repo.
You're you're you're just bringing in files and
managing it manually. I mean, the idea is
that we want the config to be just

(36:27):
available in a easy way. Of course, it's
on the Ignition server. Right? You have to
access the server, but that you could,
you know, it's easy to modify or when
I deploy a new system, I could deploy
it with configuration
already there. We're not trying to hide any
of that inside of a binary file. Right?
We want it to be available and easy
to track.
Yeah. No. That's amazing. And especially if you
have to do wholesale changes,

(36:49):
it might be easier to do it this
way than to do it in the editor.
Not that I'm an expert on using your
your software, but I can definitely see from
other products I've used that just, you know,
do a notepad plus plus sometimes
is the easiest way to make bulk changes.
So that's very interesting. Yes. So you guys
have worked with GitHub. Do do you guys
use GitHub yourself, or do you use another

(37:10):
package?
We so we use that for we use
GitHub for, you know, our source control for,
of course, Ignition, and then our we have
teams inside of Inductive that are managing our
CRM that's written Ignition and other tools. And
we use, GitHub for to manage all the
source, of that now. We've converted all the
a three because we can now do every
part of the configuration that way, which is

(37:31):
which is really great because because then we
can have separated out separate development environments or
we can then have our own branches
for,
developers. We can then make PRs to, you
know, to bring into production. We can use
that full dev you know, the deployment or,
you know, development methodology,
and we can use it now with Ignition,
which is great. That's amazing. And I interrupted

(37:51):
you. What did you wanna talk about? There
was something
else. Oh, no. I think we're that I
was that was the main thing,
I already had my folder set up as
a,
for that repo and I cleared out the
repo. So didn't I didn't push it in
there because I messed it up. But,
it's really easy with this config,
to have all that as JSON files and,
you know, and it's it's it's

(38:13):
it's all visible. Right? That's right there. So
that leads us to the next part, which
is,
to be able to go one step further,
which is how can I access that configuration,
you know, through through through third party tools?
And that's where the REST API comes into
play. And what I wanna mention is that
the entirety of this Web UI, everything you
see in this Web UI is accessible

(38:35):
in the Rest API. It's now built into
Ignition. So in fact, we built the new,
Web UI against that API.
So any any button that's in here, you
could do a third party tool like Ansible
or in your perspective application or whatever you
want. And so the way you you use
it
is you go down to the platform, you
add an API key.
I'm gonna call this token,

(38:57):
and I don't have a security right now.
So I'm gonna use my read write,
some privileges for that. I'll create it. Here's
my token.
I've got it now for use. I'm gonna
use you can use Postman or Retool.
I'm gonna use this tool called Insomnia. I'm
gonna put my token in here.
And and so now I could call,
you know, endpoints on there. Now before I

(39:19):
I call one, how do I know what
endpoints are there? Well, you go to local
host or you go to your a your
server and you go slash open API and
we give you we self document all the
different APIs that are part of Ignition. So
by looking at, like, devices and I wanted
to list out all of devices,
here's the endpoint that's there and how to
use it. And you can see there's a
whole slew of them by modules,

(39:39):
over here.
So if I go back in, I call
this you know, I wanna list all my
device connections.
There I go. There's my dairy
and, I have two of them and there's
my other one that's just my simulator.
So if I wanna get my device database
connections, there's my local MariaDB connection that's there.
And I can see all of the the
stat status, all the the the, metrics that

(40:01):
are there.
I can see all of the health checks.
Everything that's as part of this comes back
on this API.
Not only can you do that, you can
you can do actions, if you have the
right privileges.
And so I'm gonna add an OPC UA
device. Me, I'm gonna add a new PLC
to Ignition. So let's go over your connections,
devices. I got two right now.

(40:22):
Let's go whoops.
Let's go add the,
Modbus. So here I'm adding a Modbus connection.
Here's the config for it, and, boom. Let's
send that in.
And look, there it is, ready to go.
And it's gonna try to connect, but I
can now easily work with that this config.
In fact, we're gonna make a playbook for
Ansible that people can use for all the

(40:43):
different actions that are part of Ignition.
It really allows you to extend that even
further.
That's pretty amazing. But I do have to
ask, like, when we're building a skater HMI
system, a lot of times we'll have passwords
that we have to put in somewhere. That's
not in plain text, right, in the JSON
file, is it? No. So that's a good
question. And this is a feature that I

(41:04):
I wasn't gonna show off necessarily, but it's
an important one.
So if I look at a database connection,
we are storing,
passwords in here. Right? And that password is
embedded.
So, you know, if I look at the
file let's go and look at that database
connection. There's my local. You can see that
the password
is embedded, but it's it's encrypted. Right? So

(41:26):
all that they're not seeing plain text. But
that in lies the problem.
All IT departments don't want that, even the
encrypted password, to be in the config. Meaning,
if I take a backup of Ignition and
I give it to you,
you have my encrypted password. Which means, if
I were to be able to be on
your network and connected your systems, I can
run my Ignition with your backup and connect
to your systems. Right? And which is potentially

(41:48):
a bad thing. Yeah. So what where are
you going now is we have the ability
to use, this is referenced, to use secrets
providers, external external secrets providers.
And that is
here where I can add one to things
like HashiCorp Vault or Bitwarden
or other tools are out there and I
can have them manage the passwords and certificates

(42:08):
encryption keys and I can pull it into
Ignition,
if I need to. So if I create
I'm gonna use one internal here,
called internal.
And, you know, the idea if I add
a secret to this, let's call it database
and,
give it a password,
that instead
of
embedding it let's go to my database connection,

(42:30):
edit,
we're gonna reference. We're gonna reference in that
internal provider and that database key. And so
if I look at the config,
the config is quite simple. Right? Where is
it where is it coming from?
And, but it acts exactly the same way.
So that's an important distinction, something we're always
doing to improve the security posture of Ignition,
doing more and more. But these external secrets

(42:51):
providers are becoming commonplace, and IT departments
want every system to go against them. And,
of course, now Ignition can play,
play in that game and that whole system
is is is part of the SDK so
you can extend that with other custom ones.
There's you know, we always try to make
it if we don't we don't directly do
it, make it possible with that SDK.
Nice.

(43:13):
Alright. So I know we're going a little
long, but I'm gonna add one quick last
one, which is our deployment modes.
And,
this is, an important feature
for,
you know, be able to have an environmental
separation. So,
let me go over here.
Where people wanna have development, staging, and production.
And there's differences in these environments. For example,

(43:33):
a development system might have a a simulator
PLC,
whereas staging might have the test PLC, and
of course, you need production. You might have
different databases in staging and production. There's these
differences, these nuances in the configuration.
And what we've done is make that allow
you to define those nuances right directly in
Ignition. So I can add a mode, for
example, I can add development

(43:54):
as a mode,
and I can then go into my config.
Let's say I go to my database connection.
I can provide an override
for development.
And, if I look at that, it's inheriting
the core, and I can actually then make
a modification,
say, you know what? This is actually gonna
be a different IP address or a different
database or whatever it is for our development

(44:16):
environment.
And right now, I'm running the core, but
we can we have a flag you specify
in Ignition. When you when you install Ignition,
you can say, I want that to be
a developed environment. In which case, when it
starts up, it'll pull
all the configuration for that branch, that development,
branch, whereas my production system would pull the
production. So now I can actually have all
my config

(44:36):
in our repository
all
combined together,
but it's safe to move from one environment
to the x because each environment is gonna
pull its configuration
based on the mode that it's it's defined
in. And this is if you don't have
this, you gotta be careful about what you
commit or what you bring from one environment
to the
With this,
it's all safe because we have been able

(44:58):
to give you that separation for all the
config that you have. And, again, huge, huge
I say small. It's not really small, but,
like, it's very, very mighty because,
it makes it so much easier to understand
how the configuration works.
So
those are that's the big tour
of,
of Ignition 8.3.

(45:19):
There's many other features that are are in
there,
and you can say take a look at
the the change logs and change take a
look at the documentation. There's lots of videos,
lots of good stuff out there to kind
of see all the different features in action.
And what we can't wait to do is
continue to develop on these, and we can't
wait to see what people do with all
these amazing features,
and the types of applications they're they're gonna

(45:39):
be able to to get to and the,
you know, the the pain points that they
can solve,
with this really. So I'm excited to be
able to show everybody this, and, you know,
if anybody has any questions and wants to
connect me on LinkedIn or just, you know,
just connect with me, we'd love to, do
that if you have if you have questions,
and or you wanna a deeper dive yourself
into this release.
So, yeah, that that's it, Sean, from my

(46:02):
side.
Well, Travis, I really enjoyed that. You went
through a lot of stuff in a short
period of time, and you explained it very
well. I appreciate you doing that. And, you
know, explaining it as you did the live
demo, which I think those listening, we get
a large percentage of our audience who listens
and doesn't watch.
And so I really appreciate you being descriptive
like that and explaining what you were doing

(46:22):
as you were going. And, I mean, this
list of,
new features, this isn't the entire list, but
what you showed us today was pretty impressive.
And I'm sure your customers out there are
pretty excited to get their hands on 8.3.
So, I really appreciate you coming on the
show and doing this demo, and, I'll give
you the last word.
Yeah. No. I and you know what? We're

(46:42):
we're all changing industry for the better.
I I would love to hear, you know,
feedback on what you guys are doing with
these things. Go check it out. Connect with
me if you have questions and,
and or connect, you know, we we're happy
to, you know, do more of these kinds
of things. And and I I appreciate Sean,
being on the show and be able to
to share off this amazing new release. So
thank you so much. Well, I hope you

(47:03):
enjoy that episode. And I wanna thank Travis
for coming on the show and bringing us
up to speed on Ignition 8.3.
I've heard from a lot of you out
there that you use this software.
And, you know, even if you don't, it's
great to know what the other guys are
doing. Right? So I really appreciate Inductive Automation
sponsoring this episode so it could be released
ad free, and, you guys could just enjoy
this update about Ignition.

(47:25):
And with that, I wanna wish you all
good health and happiness. And until next time,
my friends,
peace.

All Episodes

Shawn meets up with Travis Cox of Inductive Automation to learn about the new features found in Ignition 8.3 in this episode of The Automation Show.

For any links related to this episode, check out the “Show Notes” located below the video.

Watch The Automation Show from The Automation Blog:

Listen to The Automation Show on The Automation Blog:

The Automation Show, Season 2 Episode 37 Show Notes:

Special thanks to Travis for coming on the show, and to Inductive Automation for sponsoring this episode so we could release it ad free! To learn more about Ignition, please see the below links:

What’s New in Ignition 8.3

Download Ignition 8.3

Ignition User Manual 8.3 Documentation

Learn Ignition and earn a free credential

Schedule an Ignition demo

Travis’ first appearance back in episode TAP 124

Read the transcript on The Automation Blog: (automatically generated)

Episode Transcript

Popular Podcasts

Dateline NBC

Are You A Charlotte?

Stuff You Should Know

.css-15opob5{left:0;position:absolute;top:0.8rem;} All Episodes

.css-14f5ked{margin:0;word-break:break-word;display:-webkit-box;-webkit-box-orient:vertical;box-orient:vertical;-webkit-line-clamp:2;overflow:hidden;}New Features of Ignition 8.3 with Travis Cox (S2E37)