>> Many customers rely on core mainframe applications as
a critical part of
their infrastructure but as they plan their move to the Cloud,
connectivity and integration with
those applications can be a challenge.
John Fancy is here to show us how
Azure Logic Apps can be the solution today on Azure Friday.
[MUSIC]
>> Hey everyone, Donovan Brown here with
another episode of Azure Friday.
I'm here with John and he's going to show us how to use
Logic Apps with mainframes.
It's funny, I've never actually seen a mainframe
before so I'm actually excited to see this.
But how do you take a mainframe and integrate it with a Logic App?
>> How do you do that?
>> Yes.
>> Or why do you do that?
>> Both actually.
>> Yeah. Let's start with the why.
I think the why is important,
it's really around how do you bridge these two worlds.
You've got mainframes On-Prem, they are heavy,
they're hard to get up into the Cloud.
They also have a huge amount of business value, right?
>> Sure.
>> People have been building on mainframe apps for like 40 years.
>> Yeah.
>> So there's still a huge customer demand to be able
to integrate their mainframes in more modern ways with the Cloud.
Really, that's where Logic Apps comes in because it
provides this incredible amount of connectivity with
over 250 connectors to
everything and now to a mainframe On-Premises,
to be able to orchestrate
your business workloads, transform, change data,
connect to SaaS applications in the Cloud as well as things
On-Premises and create these business apps out of that.
>> Yeah. This is going to be incredible because rewriting
an app isn't always the answer and it's not even practical.
>> It's not, not with
millions of lines of COBOL and a lot of these-
>> Yeah.
We're going to find a COBOL programmer to fix it anyway, right?
>> Yeah.
>> Now, you don't even have to.
What you're saying is you're going to be able to take
this modern approach with
Logic Apps and apply it to
this historical legacy type of framework.
>> That's right.
>> Awesome.
>> Yeah.
>> Cool. Show me how it works?
>> Let me get into it. Yes. The first thing I'll
show is the way this works is through the screens.
There's a few ways of getting to the mainframes.
But probably the simplest way of
doing it is actually just to drive the application itself.
The way that works is just connect to the mainframe
here and this is a live connection
to our mainframe here on campus.
I just need to login to the system.
Then you just need to clear the screens,
let's just pull-out the on-screen keyboard
and now I can go into the mainframe app.
I'll call it mainframe Mac called
Woodgrove Bank Get Account Balance.
This is CICS transaction,
so it's a four-character ID and this
pulls up my mainframe application.
I'll just show how that works.
I can put it in a person's name,
this is a banking application and put in their account number.
When I hit the button, I get the account balance package.
There's a bunch of other things I can do, I can look up
their account details and various other things.
But you get the idea that this is
a mechanism called Robotic Process Automation or RPA.
This allows me to not go through
some programmatic interface which I may
not even have to the mainframe because of the age,
modern APIs, REST-based swag,
all that kind of stuff to generate
all of that stuff automatically on top of
this as you navigate and drive the screens on the mainframe.
Then I can just pick and
choose the fields and the data that I want to receive
back and consume that from
a Logic App. That's kind of how this works.
While I've been driving this,
you get these screens on the right-hand side built up.
I end up with a sort of navigation map
where if I just pop into this,
I can click on one of
these fields and you can see these things are selectable.
I can say this is the account name,
this is the account number,
and this is where the balance is going to appear.
I then generate the connected configuration
which is when I go over to Azure.
In Logic Apps, we have something called an integration account
which lets you use transformation.
This is the type of new transformation that we have called a map.
We have XML transformation, things like Access LT,
we have JSON transformation using liquid templates and now we
have a new type of transformation which is the representation,
the format that this tool generates to
be able to drive a mainframe app through the screens.
I got this demo map, I can just open that up.
It's just a simple configuration
basically that's been built up. There's no coding here.
I've just driven the application,
recorded the interactions that I have with the data that
I type in and the data that I want to receive,
upload the map and then I can create a Logic App from that.
>> The map is the one that says,
this is where the name goes,
this is where the balance is
going to show up and this is where, okay.
>> Absolutely.
>> Now, how did I generate
this map that's already up there though?
>> We actually ship this is a sample.
You can just download this tool and we give you the tool,
we actually give you a mainframe simulator as well.
You can actually try this out without
even having a mainframe just to play around with it.
You can download the tool, you can download
the mainframe simulator and then these files,
this map file which consists of
not just the screen data elements which is a sort of
positional thing of like whereabouts on the screen
these fields appear also navigation map.
I may have three different paths I can take off
one screen and I want to automate all of that.
So it understands the relationship
between the screens that I have as well.
>> Okay.
>> That's what allows me to then generate
the configuration for that which then gets uploaded.
>> The map I assume is where you identify,
I want to call this name and I want to call this balance,
but I can reference it somewhere else in my system?
>> That's right, yeah.
>> Okay.
>> Let's take a look at that. I've just got
a really simple Logic App and I just kind of started building.
Here I have a request trigger.
I've got an HTTP endpoint on
my Logic App and I have a response where I can return data.
In the middle of that, I've got this new action which is on
the mainframe connector which allows me to reference that map,
so I just open this up and see,
the map was called demo.
Then I have this thing called a method which
actually is what was generated
the GetBalance from using
a Woodgrove Bank GetBalance sample application.
When I do that,
I will see that I have the ability to put parameters in.
I see a name and account number,
so I can select both of those.
I could just do the same thing here where I can type in
key markers and the account number but let's make
it a little more interesting because I can make
this HTTP request to get and I can just call this from
the browser and then I can add
relative path parameters and
then I can just say something really simple,
like account, slash number.
When I scroll down,
I will see the ability to the map from
the HTTP request into my mainframe connector,
so I can take the account and the account number.
Then the final thing I need to do is be able to return some data.
In the body over here,
I don't see the, just zoom in a bit.
I don't see the input fields now,
I see the output fields, so I see
the balance coming back from the host application.
>> Again, this is data that we're pulling from the map.
So the map has all the smarts in it and I'm going to [inaudible]
>> That's right. There's a really nice segregation here.
I may not know anything
about a mainframe and may not even have access
to it as the Cloud Logic App integration developer.
The people who understand the mainframe app,
the people who have really good familiarity with how to drive
all the different screens because you only want to make sure you
cover all the different navigation paths,
can drive that, generate that,
use of the tool and then give it to me I upload
it into Azure and then I can start creating
a Logic Apps from mainframe.
>> Very cool.
>> Now, I can pick the balance and I can make this a little more
interesting and say your balance today,
and let's actually pick another field because I can just say,
the account for account, oops,
it's quickly pop back is put a dollar sign in front of it.
So this is what I'm going to get
back when I try calling this thing.
Let's save this. Super-simple.
>> Yep.
>> I can then grab, this is generate an HTTP request URL for me,
it's just to get, so I don't want to
make this more difficult than it needs to be.
I can just go to a new browser tab,
type this in and this gets
interesting because now I need to find in here.
>> Oh, I see the placeholders for account.
>> You see placeholders.
>> Yeah, I saw that.
>> If I click on the right thing,
I can just move along and I can say where the account is,
I can put in Kim Akers,
make sure the case is right.
Where the number is,
I can put in, oops, the account number.
Just try that again.
Anyone remember what that is. It's quickly pop over.
Got it in notepads, make this easy.
Then when I hit the button, it's going to call the mainframe.
It's going to find the Logic App and come back with the response.
Just to prove that, I can go over to the Logic App
and so this is real, I can refresh this.
Have a look at my successful Logic App run,
open this up and you'll actually see the path that it took.
You can see the data that was received,
just going to open this up.
You can see the data that went into the mainframe app.
You'll see here's the account number,
here's the name and then you can see
the response that is formatted
to come back showing the balance,
exactly the same as the mainframe map that I have but obviously a
lot easier to use from a Logic App.
>> I see that your body is just text but I'm assuming the body
could have asked them in JSON or
some other format that I might want to pass somewhere else?
>> It could be anything, yeah.
>> Okay.
>> Again, we have full ability to convert that to JSON to XML,
Logic Apps thinks in JSON by default.
It could be HTML, I mean is this a webpage that
I just generated from a request.
So I could actually return HTML from this and
just change a content type and then I can just
render that in the browser
and that's in formatting and styling to it.
The other thing I can do because this is just an HTTP endpoint,
I can turn this into an API.
>> Sure.
>> API management have the ability to now be able to
call this Logic App from other parts of my organization.
Maybe some bot or
mobile front-end or something else and be able to
pass that data in and do the mainframe lookup on
the back-end of return data backup to the front-end.
>> This is unbelievable. He's had
my mind racing too because you're always worried about
that legacy application being
a closed box to where
there's only way to get in there is to put your hands on
the keyboard and it stifles what creativity and
possibilities that you have in your
just blowing that completely open for us.
>> Absolutely. Yeah. It really gives you access and the power of
Azure from your mainframe environments On-Prem.
>> Awesome.
>> It opens up Azure.
>> Very cool.
>> Yeah.
>> We're learning all about using Logic Apps to
access your mainframes here on Azure Friday.
[MUSIC]