Accelerate Innovation Through API-first Connectivity

This post is a transcribed version of the webinar, “Accelerate Innovation with APIs, Integration and AI”. Click here to watch the full webinar recording.

Introduction

00:00 Hello everyone and thank you for joining us today. My name is Lee Bautista with Jitterbit. I’m also joined by Dominic Dunkley also from Jitterbit.

Here’s a quick quiz with a quartet of familiar names hopefully for all of you guys. Let’s think about these companies there (WhatsApp, Instagram, YouTube and Uber), and when they’ve recently made their mark in terms of these valuation numbers that you’ve actually seen here. It’s when they went live or acquired, in the case of Uber when they were really starting to make some noise last year. If you think about how many people were there to bring these companies to this valuation, you really could be surprised by how few resources there actually were at these companies when they got there. Really looking at that, you can see that at some point these companies really came to the conclusion of do they go after composing solutions or do they go with writing code and building their solutions from the bottom up.

Composing Apps vs. Writing Code

01:36 Clearly from us too at Jitterbit, we want to show you the benefits of composing platforms and applications and intelligence versus that right side that you see on the screen where it’s just going to be lines and lines of endless code to actually build your solution on. If we look quickly at … Before we go down the road, you can see this typical blueprint of an enterprise IT infrastructure, and then you can truly understand what the research firm Gartner says with, “Future apps need much of the functionality and data sitting in today’s applications,” where you don’t want to have to try and navigate that sort of messy map of your back office.

02:16 With that, we definitely look to enable the rapid application composition for the enterprise when we look at these solutions here. At Jitterbit we want to make sure that you can build on a foundation where you’re empowering the innovation of whatever you’re looking for in your solution through integrations and through APIs.

The Integration Side

02:42 So if we just look at that one side, the integration side, you can see how we can help you modernize and harmonize your business data infrastructure through powerful integrations of your solutions and the other offerings that you have. Going back to that sort of messy network map that you were looking at, you can really see that you can take any of those solutions that you have, whether it’s like your ERP or your CRM or anything that’s within that infrastructure, and you can offer that seamless user experience that you’re looking for to come across from all these platforms you’re trying to compose and have a foundation of strong integrations to make sure that that data is something that’s shared and available to all of the users that you have.

Adding Artificial Intelligence

03:31 To even get more specific for an example, if we sort of look at an example of infusing AI with IBM Watson in there, you can get a pretty good example here of adding intelligence as sort of a key enabler for providing a better UX for everyone. With that example, this is actually kind of a good example here, is like myself speaking to you from the United States across this global audience for all of you, and in Europe, in the Middle East, and take an example of an international call center. With that, if I was a US representative and I wanted to try and talk to or communicate to some of the other call center representatives where they may be across Europe or again in Japan or in Asia, and I have that language barrier of not being able to actually speak any of those local languages. So having the ability to provide the added intelligence there to help you work through all of those language issues is really easy to embed and compose into any of the solutions or business workflows that you have.

04:44 Here’s a quick heads-up example here where if we were to build that AI functionality for translation into Salesforce here with some of the case submissions as you see, like if we were to get something in French or other languages, we would have the ability to trigger that translation through the infusing of AI through however sort of integration you wanted build into that backend so that I could easily translate any of the other language call cases that would happen. Where you can see with this workflow within our actual interface, it’s really simple to just create that as an extra step in there, where you saw from the previous screen it’s just a one button click for me and in the backend it’s just as simple to build that to make sure that we can get that translation done.

05:34 Then we also, if you look at the other half of it with APIs, to manage and to consume and sort of expose those APIs is really a part of modern business overall. If we bring up again that familiar diagram here of the messy IT back-office, you can look at where you don’t have to take down the foundation that you’ve built there, or you don’t have to code and rebuild all these pieces that you have there, when you can just use the APIs or micro services to make sure that you can access any of the data or any of the solutions or platforms that are actually already part of your business infrastructure.

The Business Benefit of API-first Connectivity

06:20 You can see that you no longer need those hundreds of developers to actually get there where people are writing those endless strings of codes. To get there you can really just do the simple API calls and use a platform like we have at Jitterbit to make sure that you can get there and get access to whatever particular pieces you need. Of course, that’s not just limited to what you already have there. You can create APIs so that we can bring together in one solution the API management part of an iPaaS offering. So it’s not just the integration side, but all the API sides as well, and enable the organization to get this done even faster through readily available APIs or even custom APIs that you can now create and build yourself.

07:08 It also allows you to publish, or we allow you to publish and enter those API marketplaces where other companies may be and where a new customer segments may be available as well. Plus, you can tap into those available APIs that are outside of your infrastructure so that if you need datasets from other applications or other platforms that are out there, that’s something that you can easily take that data that it’s not just things like IBM Watson or AI or artificial intelligence out there. You can take those third-party datasets and bring it into the fold for your business solutions that you actually want to try and get done.

The Jitterbit Solution

08:14 This is the Jitterbit solution that we offer. That’s bringing together the best of all that intelligence over a layer of APIs and integration so that you can intelligently connect all those solutions and all those clouds for the business offering that you want to have for your customers, as well as the infrastructure that you want to have to help run your business.

08:14 With that, let me bring us to the demo portion, and I will pass the controls over to Dominic. There you go Dominic.

Salesforce - Database Integration Scenario

08:24 Thanks Lee. I’ll just share my screen. Okay, brilliant. Well, thanks for lining that up for us Lee. That’s great. What I’m going to show you is how we actually do this in practice really using the Jitterbit toolset. My starting point here is actually going to be an integration that we covered on one of these previous webinars, but just to remind you the sort of typical thing you do inside Jitterbit.

08:51 What we’ve got here is a very simple sort of bi-directional integration that pulls information out of SQL Server database, and in this particular case I’ll just show you what’s in that database. I’ve effectively got a bunch of account records inside that database, and really what I want to do as part of my process is I want to upsert those into Salesforce. I’m doing a sort of data loading, data migration exercise with this. But it’s a little bit more complicated than that because once I’ve upserted those items into Salesforce, I’ve got a second operation here that takes the ideal list, the objects that I’ve created in Salesforce. I want to reference those back inside my database. So what I’m actually doing in this process, in fact what I’m going to do here is I’ll run it while I’m talking. So what actually I want to do in this process is to ensure that my database is updated to reflect the objects that I’ve just created inside Salesforce.

09:49 Again, if I go back to my database here, notice the salesforce.com ID column at the moment is blank. After having run my integration though, I’ve got all the IDs of the objects that were created inside Salesforce. I’ve got 52 rows here. I think if I go over to my Salesforce instance and just refresh this list, then you should see that I’ve got 52 records there. Pick one at random. This happens to be non Salesforce ID 10. So Commodo Ipsum here would be obviously … I’ll just pick the right row there, Commodo Ipsum, all those values create across, so very, very typical and powerful integration capability that Jitterbit provides you with this graphical environment.

Packaging Integrations to Compose Applications and Create APIs

10:41 But it is very much self-contained. I would typically run these as sort of synchronization processes, perhaps on a scheduled basis. But there is a growing requirement to package up these integrations and reuse such integrations as micro services as Lee was talking to us before. The idea then is once I’ve got these micro services as sort of standard components, they can be consumed and used in all sorts of other business processes.

11:13 For example, enabling an IT team to do the very rapid application composition that Lee was talking about before. This is an enabler to exactly that rapid application composition. Or perhaps these sort of micro services that we can build here can be made available to external parties. It’s very common these days to expose some functionality within my business to perhaps my business partners or even to my customers. In many cases those are free services. I publish an API that can be used. But sometimes they’re actually chargeable. What we could potentially do here by publishing these as APIs is add a new revenue stream to us that we can charge our customers for.

11:59 We can do all this inside Jitterbit. What I’m going to do is use this particular process here as an example and build on this to turn this into an API. The scenario I’ve got here is obviously we’ve got this integration that deals with Salesforce and database nice bi-directional full referential integrity there, a nice little integration.

12:22 But what I think I would like to do is I would like to publish an API that enables my internal staff to say take a CSV of account records, something like we’ve got here, just take this CSV file and I want to provide a service that they can just call as a web service, pass this CSV file to it, and then behind the scenes what Jitterbit will do is effectively load all the content into the database and then run this whole process through here so that content gets loaded into the database, into Salesforce, I’ve got all those referential integrity links in there as well, and I’m going to tend the user some sort of response message just to confirm that that’s all happened.

Mapping to SQL Server

13:09 The way we do this in Jitterbit, well I’ve got another operation built here. The first thing I’ll point out are these two steps in the middle. These two operations should look very familiar here. It’s exactly what we saw before in query in the database upserting to Salesforce with the resultant IDs. I’m then mapping those back down to my SQL Server database. This central bit’s the same. Obviously we have a bit at the beginning and a bit at the end that’s slightly different. So this is what I’m going to do to sort of API-enable this process.

Passing a CSV File

13:42 The first thing, remember what we’re trying to do here is we’re trying to pass a CSV file of account information that we’re then going to load into a database. This first operation deals with that particular process. You can see the target of my operation here is my database. The source is a special source that we use in Jitterbit called the API request. In other words, I’m not looking to a particular file server, or I’m not looking on an FTP site or a shared network drive or in a particular database or anything. What I’m doing here is I’m expecting this to be deployed as an API, and the data that I want is going to be passed to me by the API as the request object. In our case I’m expecting a CSV file with an appropriate format which I’m then going to map over to my database. In other words, insert the CSV rows as records into the database, and at that point I can then kick off the second part of the process which is what we’ve seen already.

Synchronize with Salesforce

14:45 Finally, by the time we get down here, I’ve loaded everything into the database, I’ve synchronized it with Salesforce, and again I’ve synchronized other information back to my day-to-day. The job is done at this point. However, there is one final step here. As I’m going to expose this as a service, as an API, I would like to send a response message back to my users letting them know this is the status of the operation. In this case what I chose to do is I thought I’d just use adjacent response message. So what I’m doing here is I’m taking the ID list of the objects we created inside Salesforce and I’m using that to generate a JSON structure, a JSON response message, just giving my users the information about all those objects that we’ve managed to successfully create inside Salesforce.

The Final Step is a JSON Message

15:40 Again, you’ll notice the final step in this process is the API response. In other words, when I’ll deploy this as an API, I’m going to send that JSON message back as a response message across my API. It’s not an earth-shatteringly different integration flow. I just sort of enabled it to be used as an API.

Publishing APIs

16:01 So how do I expose it as an API? That’s the big question here. Normally within Jitterbit when I deploy this, I can schedule it and that’s, okay, well that gets me so far. But that’s not what I want to do here. In this particular case, what I would do is deploy it to my management console, and then if I actually quickly flick over to my management console, just to catch it before it logs me out … I did miss it. Just log in again quickly. Inside my management console one of the things I can actually deal with here is API management. We’re interested in this section and you’ll see there are three different things I can do. I can either expose integrations as ODATA Services, particularly useful for sort of dynamically tapping into other applications, very commonly used inside Salesforce. In our case though I want to create a custom API, a restful API that can be used in all sorts of different scenarios.

Creating an API Authentication Profile

17:00 To support this sort of custom API I can also create API authentication profiles. I’m not going to apply these profiles to the APIs that I build. In this particular case I’ve got three different APIs. We’ll have a look at this internal staff one. If I just edit this, we can have a look at the properties associated with this profile.

17:22 This profile is associated with a particular Jitterbit environment. You can have different profiles for each of your different environments that you create within Jitterbit and they’re completely self-contained. I’ve obviously given it a name. This profile is obviously aimed at my internal users. Because it’s for internal users, I don’t need to go too overboard in terms of authentication and identification of them. All I’m doing here to authorize them is I’m just using a basic authentication profile, whereby my users are going to log in with a username and a given password and that will identify them to me as internal users.

18:04 Because I’m quite happy that they are internal users, in this particular case when I log any of these calls, I’m just going to use the username that they’re all going to sign in with this particular username. But perhaps if I was exposing this is an external API, then I might want to use a custom request header to log all activity associated with this API. Typically, that might be something like the IP address of the end user.

18:34 Also, for restriction purposes then I can also bolt this down a little bit further and restrict the IP address range that is allowed to be used in this particular profile. Again, because this is internal staff, I’m not going to actually apply any IP restriction to it. But if I wanted to, then I could specify individual IP addresses or groups of IP address ranges that I might want to authorize end-users for.

19:04 I’ve got a profile that I can then apply to any of my integrations that we’re going to build. That’s really where the fun starts. If we go back to our API management platform, and let’s think about building a custom API. This shows me a list of all the APIs that I’ve already got deployed in my environment. But what we want to do is build a new one from scratch. So let’s create the new API button.

Creating an API Button

19:31 There are a couple of different sections of information that we need to fill in. The first is the summary information. It’s the sort of the heading, the way I address my particular API that I’m going to create, and it’s made up of a few simple components here. First of all, which environment is this API going to belong to. Again, I can restrict APIs or have multiple different APIs give them the same name, but they actually point to different Jitterbit environments.

19:59 Let’s give it a name. Let’s call this Import Accounts. Import Accounts, if I click to the next field it says, okay, well, this is your user-friendly view of the world. This down here is your API-friendly view of the world. Perhaps just give it a version number as well and give it a version number of 1.0. Maybe I’ll add a description explaining what this is all about. You might notice up here, the service URL has been created dynamically as I type these values in here. So you can see which particular environment we’re using, what the version number is, and actually the endpoint for my rest web service. This is actually going to be my restful URL that points to my web service.

20:46 Now that’s configured. What I need to do is assign particular operations to it. So when I hit this endpoint what’s going to happen in the Jitterbit world? Well, this is pretty straightforward. All I need to do is pick the HTTP method associated with this endpoint. I could have any unassigned type here or custom type, but I’m just make sure we use a post message in this particular case.

21:12 When I post to this endpoint, I’m basically going to pick a particular project, I think it’s somewhere down here, so this project we’re interested in. And then from within that project, I want to call one of my operations. The operation we just looked at in Design Studio a moment ago is this, Insert Accounts from an external CSV. Simple as that really, associated this particular operation with this particular restful endpoint.

Response Message

21:40 The final bit of configuration here is my response message. Once I’ve executed this operation, what am I going to send back to the API? Well, you’ll notice there are a few things. Obviously no response is pretty straightforward. I’m not interested in sending any response back. I can use a system variable inside my Jitterbit operation so I can build up a complex structure of a response across the entire operational chain based on system variables.

22:11 But in our case I’m just going to use the final target. You’ll recall that what we did inside Jitterbit we said, this is my API response, so whatever I get from this transformation is effectively my final target, and that’s what I’m going to use as my response here. Let’s assign that operation to this particular method. Obviously if I wanted to, then I could add additional operations to different methods associated with this restful endpoint.

22:39 What I’m also interested in doing here is providing those authentication profiles. As it stands at the moment, this API is completely open to anybody that can view this URL. That’s not really what I want, so I just want to restrict this to my internal staff profile. Let’s assign that profile to it. Again, a bit like we could have various different HTTP methods for calling this web service. There’s absolutely no reason why I can’t attach multiple authentication profiles and to change the way that this works depending on how I call this system.

23:16 There is one other little bit of information here, some generic settings. I’m now going to restrict this to HTTPS only, specify some timeouts, I’m going to turn debugging on for this API and what-have-you. I’m just going to leave these as default settings at the moment. Click the Add button and then we should have over here a new Import Accounts API that we can test out.

Testing Out the API

23:41 Let me just copy the URL of this web service to the clipboard and then what I’ll do is I’ll move over to my test suite. So in this particular case I’m going to use Postman, a well-known HTTP posting tool to test out my API that I’ve just built. Let’s paste in the endpoint there. Notice we’re going to make this a GET request. Well, I’ve specified that we need a POST request. Then in the body of this request I need to add my CSV content.

24:15 Let’s get my CSV content from here. Let’s just simply copy that and paste that into the body of my request. At this point I should just be able to test this out by hitting the Send button and will send that request off to our API, and hopefully we get an interesting response message. Well, let’s just put that in preview mode. No such API. Okay.

24:41 What’s actually happened here is the API is not actually been published yet. There we go. Try a couple more times. Just waiting to get through to the system and it’s published. I’ve got a system error here, 401 unauthorized. Sorry, the requested resource requires user authentication. Of course, it does. I applied an authentication profile to it, but in this request I haven’t specified any authorization information. This was just a general open request, so it’s been rejected and that’s essentially what this system error is telling me here.

Adding Initial Request

25:16 Let’s just add that to our initial request here. We have no authorization. I’m going to use basic authentication here, and I’ve already got my username and my password filled out here correctly. Let’s update the request with this new authentication which will add a new header to my rest service in basic authentication format. Let’s give this a whirl now. If I hit the Send button now … It’s interesting. If I hit the Send button now, we’ll resend that information. Notice this is taking a bit longer now because I think we’ve got through the authentication barrier because I’ve got appropriate credentials there that it recognizes.

26:01 Let’s put that in a slightly different mode. You can see that by way of a response now I’ve got that JSON file that is showing me all of the different records that have been created. Again, just to prove the point, we could go back to Salesforce which previously showed us, I think it was 52 records, but now we have 72 records. Let’s pick one of these that has a high number. So this one here for example has a very high number of 64 as the non Salesforce ID. Again, just to prove that we’ve managed to upsert that information here. Let’s refresh this data set inside my database and we can see that we’ve now again jumped to 62. I think we were looking at, what was it, 64 was it? No, yes, I’ve got 64, so that’s the appropriate record that corresponds to the CSV that we’ve uploaded.

Conclusion

27:02 Hopefully you can see this is a very rapid way of publishing a Jitterbit integration as an API and it just shows you how easy it is to sort of microservice enable your integration platform using the Jitterbit application.

27:21 With that, that concludes the sort of technical part of the demonstration today.

To watch the full recording of the webinar, click here.