Hi. Today we're going to talk about IBM Integration Bus,
and specifically the creation of the default configuration.
We do this through the Integration Bus (IIB) Toolkit,
so we'll start up a copy; so let's imagine that you've downloaded the
Developers Edition of IIB or an earlier version of Message Broker
and you've installed the product and you're ready to start testing and
working and doing some integration work.
So let's start up with a nice clean workspace;
in a clean workspace we are
presented with the welcome
area here. If we go into Getting Started,
we'll see that there is a Create Default Configuration (option).
This will launch a wizard for us,
and you notice you can create the default configuration;
you can also remove it clean up the system as well. We'll start off
with the Create Default Configuration wizard; so we'll kick off the wizard,
so what this is going to do for us is its going to create
the MQ queue manager for the integration bus
version 9 node, which represents our runtime integration engine.
As you see, it's going to create a queue manager named IB9QMGR ("I..B..9..queue manager").
Its going to be listening on port 2414,
and it will then create the IB9NODE
(I..B..nine..node) upon that. So first of all it goes off, and it needs to go and check that
these entities don't already exist; and then it goes through the process
of actually creating the two artifacts, configuring the queue manager with the
brokers or integration node system queues and
then set up the connection between them. There you have a fully-functioning
IBM Integration Bus version 9 node, that's ready to go.
So we'll just let the wizard complete its task
[Configuration continues...]
And there you go. So if we take a look, we can just run down through
what has actually been created, and make sure we're all successful.
We can open the log file and review those results in the log as well.
We can also move to the samples and prepare the system for deploying samples.
We might do that later...
For now, ...
lets close the welcome banner and move to the
Integration Developer's environment within the toolkit. And what we see within here
is we've got an IB9NODE (I..B..9..NODE) created,
which is running on top of the IB9QMGR (I..B..9..queue manager)
with an execution group (or integration service) called 'Default',
and this is where we would actually deploy our integrations to.
You notice we've got no applications, services, or libraries created at this point
but in the background here you'll notice the MQ Explorer,
and we can see the queue manager has been created with all of its channels,
system queues, etc, and if we look down here we can find
there's an administration area inside the WebSphere MQ Explorer
for the integration node as well, just as for the IBM Integration Bus Toolkit.
So let's create a little artifact, a little message flow
that we can actually use to test things. So the container for
integration flows
and message flows are called 'applications' and this is where we might group a set
of artifacts together
to do it specific task. In this case we are just going to create
one message flow, some people call them mediations,
just so we can do little IVT (verification) test of the system.
So we'll create a flow called 'flow1' and we're presented with a blank canvas
and of course we have all of our MQ nodes, we have HTTP, JMS, ...;
all the many things we may want to do in terms of mediation within a message flow.
In this example we're going to do something very simple:
we'll take an MQ input, which does an MQ get;
we'll take an MQ output node, which does an MQ put;
we'll wire them together. And what this message flow will do at runtime,
is we'll configure it to do an MQ get
against an input queue, called 'INQ',
and just for readability, we'll give it a nice name.
And then move that message without operating upon it in this example
to an queue called 'OUTQ', and once again for readability
let's give it another name.
So we can control this to say we've now created
the most simple mediations; we're just going to move messages from one queue to another.
So we can now deploy this application,
and we can move it out and deploy it into the default execution group.
But the first thing we need to do here, is we need to move across to WebSphere MQ
and let's go create our two queues (our source and our target queues):
'INQ' ...
and 'OUTQ' ...
So now we can deploy our application, containing our one message flow.
Just a simple drag and drop in this example. You'll see its creating a broker
archive file that's the deployment object
similar to an EAR file in the application server world. And we should see
that our test app is deployed and our message flow is there and running.
If we move to MQ
we should see that we've got an MQ input count on the INQ, and we know something has that
that queue open for input.
How about we stay outside the Toolkit initially, and let's put a message on the input queue:
'Hello out queue'.
And Refresh shows us that now the message flow has the output queue open
and we'll notice that there is a message on our output queue.
And if we do a quick browse of that, we can take a look
and there's our message data. So the message flow is successfully deployed
and running.