The Top ActiveBatch Alternative: JAMS Scheduler

0:00 Intro
Hi, welcome to the Cutover. I'm Katie Thompson from JAMS. If you're watching this, you don't wanna hear from me. You wanna see an actual cutover from ActiveBatch to JAMS, so I'll keep this fast. JAMS is priced per agent starting at $833 a month, billed annually. Add jobs, the bill stays the same. And JUMP, our migration tool, is free and reads ActiveBatch. Darrell Walker is about to show you how it works. Darrell, take it away.

0:33 The five-step migration process
So as you just heard, we have tons of experience converting customers like yourself from their current solution to JAMS. But you're probably here wondering, what does that process actually look like? And the truth is that every migration is just a little bit different, but typically, they're all gonna follow this same five-step process. So the first thing you're gonna do is send us an extract. This is going to in-include things like the job plans, the jobs, schedules, and dependencies. This is done via the export wizard in the GUI, and it's to come out into an XML file. We'll analyze that, and we'll send you a conversion assessment typically within five business days. From there, we'll build the migration plan, and this is going to include things like the timeline, the date you have to be cut over by, and who's gonna own each part of the process. Next, we'll convert. So JUMP can translate many of those jobs and objects from ActiveBatch to JAMS automatically. But for a more complex environment, our service team works with yours to build the jobs and hands you that finished product. And next, we'll finalize. Once everything is built in JAMS, your team validates, so nothing's gonna get cut over without your testing and sign-off. And then we do cut over. So move the jobs across in stages while ActiveBatch runs alongside until that trust is established and everything is cut over

1:43 A two-week migration at the Virginia DMV
We recently had a very successful ActiveBatch migration that we were able to achieve and complete within two weeks. So that's with the Virginia DMV. Actually from the first day they talked to us to, you know, their completion, was very, very quick. Small environment, obviously, 80 project-- production jobs, you know, obviously not every migration is gonna be able to go that quickly, but does go to show that, you know, we're really here to help and move as quickly as you might need us to.

2:10 What converts from ActiveBatch
So again, one of the things you probably wanna note is what is actually going to convert automatically and what is of this I'm going to have to do by hand? With ActiveBatch, typically we convert the majority of it automatically. So that's going to include things like your jobs, the job plans, folders, schedules, dependencies between jobs, all that typically comes over pretty cleanly. Additionally, we can map things like your variables, you know, retry information of the jobs and how they're going to restart, email notifications to corresponding JAMS equivalents, those types of things that are associated with the jobs as well. So provided we have the most complete data set possible, from those extracts, we can typically do most of the heavy lifting automatically

2:51 What needs a person
You know, it's not obviously going to be a, a magic pill here. We're not gonna be able to take everything in your current environments and automatically convert it into JAMS. That's just not something that is going to be possible. There's really too many ways that, you know, you guys build jobs in these platforms to really be able to account for every possible iteration. So some things aren't going to line up one-to-one. And for those, we'll typically build those by hand or maybe rework them to fit how JAMS handles that same scenario. So those would include things specifically like multi-step jobs, and even more specific, within those that's, that have conditional logic and looping scenarios. And it's not that JAMS can't handle those, it's just harder to build automated conversion for those types of scenarios, as typically we may need to look and evaluate exactly what that process is doing to figure out how it should map into JAMS rather than trying to force it into a, a JAMS workflow. The next one is gonna be active variables. These are things that are tied to dynamic data sources like a SQL query, a script, things like that, where we're evaluating or pulling in information to feed that into a subsequent job perhaps. So again, something we're gonna have to evaluate and determine what the best path of action is to get that into JAMS. And finally, we get SQL Agent jobs as another example. So typically, the job extracts that you get from ActiveBatch for SQL Agent jobs specifically are gonna reference the GUID of that SQL Agent job in SQL rather than the name itself. So we'll have to go and find out what that GUID correlates to in that SQL database to be able to reference that in the JAMS job as JAMS uses the name. So just a couple of, you know, items here that, you know, the twenty-five percent or so like we talked about, that is not gonna be automated, that maybe we have to go and our team and your team work together to figure out, how to get this information into JAMS.

4:34 What JUMP is
All right, so to help with some of these scenarios, again, we built a conversion platform called JUMP. So that's the JAMS Universal Migration Platform, and it's really designed to ease the ability to convert a lot of the, you know, the items, the objects, the jobs from, your current solution into JAMS. So no risk for you to use. This doesn't require any sort of connection to JAMS to do a dry run, so nothing's gonna get migrated. It just gives you a preview report. But if you do wanna do the conversion, we can run that through a full conversion and, again, see potentially up to 75% or so of those things processed automatically. So with that, so go and take a look at what JUMP looks like in action.

5:13 Extracting ActiveBatch jobs
So here is the JUMP platform. So again, we can convert from a variety of sources here. For today, we're going to choose ActiveBatch over here on the right. And the first thing we're gonna do is, again, grab that extract file that we have exported previously. So again, that's gonna include things like, you know, the job plans, the job information, schedules, all that type of stuff here. So we will select our file And we also have the option to create subfolders per plan, which kind of means that we're going to take those, those job plans, and we're going to create sequences out of them because that's, a good correlation between how ActiveBatch processes those jobs and how JAMS processes those. So we have the option to do either/or. We can check or uncheck that, and that kind of affects the next step of, of how we're going to migrate. Then we click Extract, and we can get s-- a nice list of all of the jobs in all of these folders. We can select, deselect, any of these that we may want. And you can see here, you know, we see all the information about the folder that the jobs are in, the job names, the type we're gonna convert to, the schedule, the folder, in-informational and warning messages about, about what may not convert or what you may need to look at post-conversion. So, you know, here we can see that this one has five jobs, but it doesn't say if this is going to be a sequential or parallel processing. So we're just saying, we're inferring because no job relationships were given, these are all parallel processes. They're gonna run concurrently, and just to take a look at that. And in here, we're giving you a warning about this was sent to an ActiveBatch pool, which is a little bit different than how JAMS, batch queues work. So again, just giving you a warning, take a look and make sure that this is going to be sent to the machines that you're intending. So we give you that breakdown here on the right of all the different types of things that you may wanna take a look at, as far as, as the different jobs go. So you can select and deselect any of these that you want, and when you're happy with that, you can click Continue.

7:11 Running a dry run
And here's where we figure-- configure the JAMS target information. So again, we don't have to configure anything here if we don't want to. We can run this in dry run mode just as it is today. And that's just gonna give us a nice report. So let's do that first. We'll click through the dry run. It's very quick. We can see that it would convert all one hundred and fourteen jobs of this extract in some form. Nothing was skipped, nothing failed, and we can see all the additional supporting objects that were also built here. So that's again, things like our folders, agents, credentials, queues, et cetera. We got some logs and report type data that we can download down here as well.

7:42 Reading the dry run report
So we take a look at, for example, this HTML report. Again, just gonna give us all the information about what would have happened, in a nice, concise, readable format. So going to give us here, again, results outcome at the top, those supported objects as well. And here's some of the warnings and informational messages about what is in this and what types of things you may need to do manually, either fix or just verify information. So again, we can see that, here we've got a sequence step at this point, something that actually wasn't in this extract, so it looks like we didn't get all the information that we needed. This one has some active variables that we're seeing here. So just again, give you a nice per job or by job list of all of the different things here that you may need to go through and look. And then again, a nice table at the bottom that we can use to search and filter, again, to give us, you know, the information about what would have happened in this particular example.

8:36 Running a live migration
So once we're happy with that, we can run through the actual conversion itself. So we come back here to JUMP. I'll click Start New Conversion. We'll go back to ActiveBatch and select our extract one more time Extract our jobs out. Again, we're gonna leave everything here. We'll click Continue, and this time I'm gonna uncheck my dry run, and we'll fill out the rest of this information. So the first thing it's gonna do is ask you for the base URL of the JAMS server. This is actually the JAMS API service from the web server. And then it wants our API token itself, so we'll grab that information here. We can test that connection to make sure it's working. We can also give it a target folder. So this is my company, Northwind, so we'll put it in that. And we'll go ahead and give it a, a prefix of, or a postfix of AB there so we know that this is for ActiveBatch. So what this is going to do is, as we know, I've identified the folders from the ActiveBatch extract. It would just create those in the root directory, if we don't leave this… if we leave this blank. But we can say we want to put this, folder on top of that. So maybe in that previous selection, I'd only chosen, jobs of a certain, certain departments or my production jobs or my QA jobs, and I want to stick those all with underneath a certain folder here in JAMS. This just gives you that additional flexibility to kinda do that on the fly without having to go back post-conversion and, and move some of those things around. We also have some overrides here. So, you know, oftentimes when you're migrating, you may want to modify the target machines that are running jobs, you know, your agents, or maybe the credentials used to execute those jobs as well. So this is kind of a blanket override for both Windows and Linux and Unix jobs. You can see corresponding to a few different job types. So basically this would take whatever agent and credential is in the extract and override it with whatever values you stick here. So again, just give you some flexibility to be able to modify things on the fly as you're doing the conversion process. And then here at the bottom, we have checked by default this disable all job triggers on import. So as we build these, you know, maybe they have schedule triggers, job triggers, things like that. We don't want those running and firing as soon as they're converted. So we wanna make sure those are all built, but they're disabled, so nothing is executing until ready for it. So that's on by default, and we'll leave that checked. So we can click Import now, and it's gonna run through this pretty quickly. We can also stop this if we realize we made a mistake and go back and fix things. There's also some-- gives some help documentation in the top right. So, we've got a Getting Started section, tells you how to use JUMP, how to, to figure out the URL, what things can be migrated, how to get an API key out of the web client, things like that here of, of just basically how to use this particular product. We also have some, s-source-specific information. So if we go to ActiveBatch, for example, we can see the information here about, what information we need for the extract, things that, you know, get converted here easily, things that don't get converted, automatically or need to be looked at, and just some gotchas and things to be aware of as well. So try to give you the most information possible about the things that you might see, the things that you may need to look at as you're doing this conversion process.

11:40 Reviewing the conversion results
So we can see here in the background that we were able to form this conversion. Again, we got our results here. Hundred and fourteen succeeded, all of our supporting objects. We did have a few items in here that actually already existed or some items that need attention. So as we're building credentials, these are almost always going to fall into this need attention category because we don't have the passwords for them. There's no scheduled app that is going to export the username and password combinations. You'll get the username and the name of the credential, and that's typically it. So just telling you that you need to go back and update that information in JAMS. A few other warnings here, basically, again, users, you know, making sure that things are set up correctly for the agents and the queues, things that were built, sometimes they don't contain all the information from those sources. So again, we can download our report here and take a look at it, and it's gonna give us kinda that same types of information that we saw in the previous one. Again, supporting objects that may need some attention here, and then all of our jobs and any manual verification steps that we need to perform.

12:39 Checking the jobs in JAMS
So from there, we can come in here into JAMS, and we'll go ahead and log in and take a look at what this conversion looked like. So if I log in with my account Come over here to Jobs, we should see our Northwind AB folder that we built. And underneath that, we'll have all of those subfolders that were created as part of this process. So here we can see, all of these processes here that were created. These are all Windows command jobs. You know, we can go in here and look at these. We can check out the source. And we can come back up here to, you know, the sequence that it built out of all of these as well. So it was able to take all of those processes here, and again, these were parallel processes in this instance, so we can see those all lined up as well. So again, aimed and designed to help you get things into JAMS quickly. Obviously not going to be 100%, but it's gonna get you a lot of the way there and just with some probably manual cleanup afterwards.

13:45 Services, fixed bid, and training
All right. So again, JUMP is great. Obviously not a one size fits all solution though, right? So every customer can have, different skill levels, different timelines, just different needs overall. And we're here to be your partner through all of this. So we do offer migration services. These are gonna be typically fixed bid, where the number that you approve is what you're going to pay, regardless of the timeline that it's going to take. Some even qualify for a free migration, so go ahead and ask us, you know, during the process if that's something that is available to you. And training is always part of this offer. We don't, offer it as an upsell or an add-on item. As we're doing this migration process, we want you guys to be successful, so we're going to teach you how to use the product and what the best practices are as we're going through the migration, as we're building things out in JAMS.

14:28 Two ways to get started
So two ways to get started. Go ahead and download JUMP. You can run your extract through in dry run mode, get a preview of what's gonna come out, what may need to be, to be modified. Nothing's migrated, no connection's required for that to work. You can also give us a call. You know, we're happy to talk to you, schedule a demo with us, get some initial pricing on it, so we can talk more about what your particular use cases are and, and how we can help you guys out.

14:52 Wrap-up
So with that, I'll pass it back to marketing. That's a cutover. Every environment is different, so here's the next step. Download JUMP and run it on your own jobs or book time with our team. Bring your job count and your renewal date. Links on the screen. Thanks for watching