As a technologist, there comes a time when you write your applications and the code necessarily has to grow,
especially when you have the need to interact with other systems.
Or, better yet, another scenario is where you've built your application,
it's running fine in production, but let's say you need to connect to other pre-built systems that are functioning.
Did you know that there's a whole discipline dedicated to this type of integration?
Hello, my name is Jamil Spain, developer advocate with the IBM Cloud.
And my topic for today is application integration.
And let me go ahead and define this topic;
I think you already are aware where I'm headed here.
Application integration is the process of enabling individual applications to communicate together.
Very simple, but the key about these applications is they're already designed for their own purpose.
So let me go ahead and write this down here.
So we'll just say it enables...
I'll abbreviate communication with "comm" here.
And I really want to talk about this topic from the perspective of you having your architect hat on again,
but noticing when you need to use application integration, and there are four scenarios that really come to mind.
A is when you have to interact with different protocols, formats, data operations, or my favorite, SaaS connectors.
So let's get started talking about all these four areas, and then we'll summarize it all at the end.
The first are protocols, and when I think about protocols is really the most major
one is going to be HTTP, definitely top of the line here.
You also have protocols like you may actually have to deal with files or maybe XML.
A lot of the popular services leverage that kind of protocol. Or maybe even some messaging protocols like AMQP.
Messaging protocols that are there, web services --
all these are different type of interactions that I need to create between services,
and this is probably the most common ones, especially when you start dealing with web sockets and a lot of SPA applications.
There are so many different things that you have to interact, type of protocols, or systems that you have to interact with there.
Secondly, formats. So formats really gets you into, you know, a lot of larger enterprise business.
They already have protocols or standards that are set up for these systems to work together.
Things that come to mind here are
definitely when it comes to a lot of EDI,
when it comes to how business-to-business may interact with each other.
So a lot of B2B.
In health care, there is the HL7 format, which really talks about
how health care companies and insurance companies kind of communicate together to work.
The next is SWIFT.
There's actually a complete
network that set up for a lot of banking institutions and
marketplaces to actually communicate with each other worldwide,
and so at some point, you have to interact with, if you're writing your own custom applications,
you'll want to have to interact with that system.
And so definitely when you need to embed into those particular interact with those other systems,
getting your data in the proper format is necessary here.
Great use case for application integration here.
Let me talk about SaaS connectors.
So we have this big growing need for the API economy,
and it's really blossomed to almost where almost any third party service has REST APIs that are available for you to interact with.
And so it's almost to the point now that I can even sign up for SaaS service,
interact with the service without actually having to log in, thus giving my application that I've built
the immediate benefit of all the services and formats or functionality of these SaaS connectors provide here.
I really want to break those down by the actual REST API.
So you have REST.
And it's going to provide three different - four different operations that are very critical.
All right, we're talking about one part and that's the CRUD,
that's the ability to create,
read, update and delete.
But not only for the ability to interact with those systems based upon these kind of four basic operations,
there also is an ability to provide some event web hooks. they're called call web hooks -- let me breeze right into it --
So as their web hooks, they provide the callback based upon any of these operations.
So let's say, for instance, I am building an application where I need to manage a list of orders or products,
and as I may be interacting with another SaaS service that may handle that functionality for me,
when I create products to go into inventory, I can also get a callback when a product is created.
So it'll kind of give me a
functioning another REST call that I can listen for to know to make some interactions there as well.
This really starts - it really is the start of a lot of event driven type of functionality that you can provide your application.
And of course, these events can function across -- denoting
that is a kind of iterative cycle here -- as I make operations, I can also get the feedback from that
and immediately enable a lot of the functionalities there.
The last one I want to talk about is data operations.
So not only will do I have to interact with other systems
and different protocols, maybe interact with other systems in different formats that they function with,
and I may actually also interact with other SaaS services.
The lastly is I want to actually enable particular operations that I want to occur.
So.
Things that come to mind here are routing and transformation
going to abbreviate transform here.
So routing where I want, depending on the data inspecting the data payload,
I may one data to go any number of services route to different places.
I may want to have a response that comes in through REST
and I may want to transfer that to XML format to interact with another system and then push that data along.
Or break a large payload into smaller payloads to go into other systems.
Maybe I want to actually interact with other systems like Kafka or any other messaging system.
And I started out from a HTTP call.
All right, some type of web service API calls here.
So a lot of great opportunity there to function and work there.
Next is filtering.
And I kind of alluded a little bit to that already where I can kind of inspect the payload,
maybe make decisions based upon things that I want to do.
And this can also involve some other patterns that are very great to have, which can be kind of the
publication and subscribing format or what I like to call the scatter/gather pattern.
All right, so think of pub-sub where I have something that's publishing information
and I want to -- we'll just use my air quotes -- and say "spray that data out" to multiple receiving sources
who have an interest in that particular thing.
So let's say the user creates an order or submits their order on an e-commerce site.
I may want to enable calls to go out to multiple APIs that handle different departments.
Or in the scatter/gather method, I may want to pull off the functionality of I want to kind of pull data from different sources
and correlate that all together to go back.
A lot of your common use cases for looking for better prices on services kind of enable that kind of pattern.
You know, I give my basic information.
It goes out and checks multiple services, comes back with a nice list of all your options that are there.
All right. So common pattern that's achieved with.
Now let's get back to the core principle here.
Why this is kind of useful.
We talked about protocols.
These are situations where application integration really should ring a bell that I need to look into this for as well.
So with my applications, I'm going to be writing a lot of this code myself.
It is code, and we all know that code you write, has to mature.
One of the great benefits of leveraging the
ecosystem here for application integration, is this is probably going to be facilitated by low code or no code.
Meaning they are pre-built applications that really can enable a lot of this functionality.
Maybe its connections to SaaS services,
but I get to kind of just focus on the business logic aspect of that, leveraging by drag and drop UIs
to do data operations to do my filtering between services or translate between different data formats
kind of really facilitate a lot of this functionality there.
And by the fact that there are already pre-built,
already they are running, it gives me the consistency and the comfort to know that that part of my code,
I don't have to test too much because I'm just interacting with that.
It performs a certain function and really helps expand the bounds that your application that you're writing
or context of your application can really grow and connect to many, many more data services.
So this is all I wanted to cover here on the topic of application integration.
Definitely hope that you'll give me all your feedback or questions or comments
in the comments below, and I look forward to seeing you next time.
And oh, while you're there, don't forget to like and subscribe to our channel
so we can keep bringing you great content on topics like this.
Until next time, technically yours.
Jamil Spain.
If you have any questions, please drop us a line below,
and if you want to see more videos like this in the future, please like and subscribe.