Integrate 2018

June 4-6, London


Johan Hedberg demonstrates the power of using VSTS with your BizTalk projects by showing how to set up CI and CD, configure BizTalk build projects, and more using VSTS.

Using VSTS to deploy to a BizTalk Server, what you need to know

Integrate 2018, June 4-6, etc.venues, London


Video Transcript

I’m here to introduce Johan Hedberg who’s a cloud integration specialist and a Microsoft MVP for nine years. His session has all you need to know about using VSTS to deploy to a BizTalk Server. Ladies and gentlemen, please welcome, Johan Hedberg. Thank you.

Johan: Okay. Hello, everybody. I got some couple of extra minutes there from Mike, and hopefully I’ll be able to give you a couple of extra minutes for your break as well. I’m not intending to run over, so we’ll see. So my name is Johan Hedberg. I’m a nine-year MVP. I’m based out of Stockholm, Sweden, and my session for the day is using Visual Studio Team Services to deploy BizTalk Server solutions. And so I wanted to give, first off, kind of a declaration of the Swedish National Day which is actually today. So for all of the 100-plus Swedes that were supposed to be in the audience, I’m hoping you’re still here because there’s actually a holiday today. Oh, applauds even. There you go.

So instead of being out in the sun with the family, you’re actually in here and listening to all of us guys instead. So I appreciate that. So the way I’m planning to do this session and the audience I’m trying to target is for those of you out here who are not doing automated builds and deploy today. Or those of you who might have looked at doing it with Visual Studio Team Services yet. Or those of you who haven’t looked at Feature Pack 2 yet, and wanna see what that brings and how that changes things or if it changes things for you, right? So the session as a complete title then, kind of, becomes using Visual Studio Team Services and BizTalk Server 2016 Feature Pack 2 application projects to establish a build and deploy, or a continuous integration, continuous deployment pipeline for BizTalk server 2016 solutions, which is really too long to put on the first slide, but I managed to get it in here instead.

So I’m not planning on having a lot of slides for this session actually. I’m planning on doing most of it as a continuous demo. But to, kind of, just set the context of this, so what we need to go ahead and do before we even start out is we need to install and configure the Feature Pack. So, obviously, I’m not going to force you to watch me actually downloading the file and configuring it. For those of you who have actually installed the feature pack, it would be good to know, though, that as opposed to your other parts of the Feature Pack, for this, you don’t need to actually do any configuration, you just need to install it. We’ll then go ahead and create all our BizTalk solution.

And again, I’m not going to force you to watch me actually create a BizTalk solutions. So I’ve created a very, very simple BizTalk solution that this complexity of the BizTalk solution isn’t a target for this, so I’m not going to bore you with that either. What I’m going to do is though, I’m going to configure the BizTalk application project. I’m going to commit the updated code that I will build to the Git repo that I have set up in Visual Studio Team Services. I’m going to talk a little about downloading and installing the agent which you need to do. I’m going to create build definitions and build the BizTalk solution in Visual Studio Team Services, as well as also make sure they we’ll run our unit tests, just so we know that our solution is okay. I mean, after all, we’re doing continuous integration.

So we need to make sure that that build doesn’t really, you know, destroy anything for us or for our fellow developers. I’m going to, then, go ahead and create a release definition as well and deploy the BizTalk solution to my server. And then we’re going to look a little bit in the end, at what do you need to do more, where do you go from there, how do you add additional scripts, how do you trigger those as well. So that’s the lead in to my demo. So again, I do have a BizTalk solution here. It’s as simple as it can get, apart from the fact that it’s actually two projects. So I do have my project over here that has my Schema files. And I have a project over here that is my orchestration and my maps.

So just to make sure that we have two projects that I actually have to handle references as well. So you see how that works. But other than that, it’s super simple. I’m not going to even going to show it. It’s received location. It’s an orchestration. It does a map. It sends it out, all right? That’s what it does. So the first thing I need to do here to get this working is add the BizTalk application project. So I’ll go ahead and go to Add, Add New Project. And I wanna be able to find this new project type that we now get in this, which is the BizTalk Server Application Project type over here. So let’s go ahead and add that. I’ll call that HelloWorld.Application. Now I can name that whatever. I’m just using this as a naming standard for this thing.

So when I add that, I will get two files in this. I’ll get a binding file, which is just an empty placeholder and I’ll get a file called BizTalkServerinventory.json. So this is the… Let’s go ahead and zoom that to the correct location just so you in the back can see this very well as well. So in this file, I have a couple of sections that I need to configure to do the deployment. So, first off, up here, I have my BizTalkAssemblies. So obviously, I wanna have BizTalkAssemblies in this deployment. So we’re going to add those as we go along. I have my BindingFile over here. If my mouse will stop jumping around. I have my BindingFiles over here. I have some…I’m going to use my trackpad instead.

Right now, the mouse is actually disappearing when I go into… This is not good. There we go. I have some additional Assemblies over here. I have sections over here called PreProcessingScripts and PostProcessingScripts. I have additional Files, and then in the end over here, I have one of the most important sections in this, which is my DeploymentSequence over here. Okay? So if we actually go ahead and open up the BizTalk Administration Console, what you’ll see is that these sections correlate very closely to, if I would go to my applications over here, open one of the applications, go down to my Resources, go ahead and go add resource over here and then just add some resource. Let’s go with that. Why don’t we? And we look at these sections over here.

So these are mostly the same sections, right? So you can find the BizTalkAssembly, you can find the additional help Assemblies, you can find the Bindings, PostProcessing, PreProcessing scripts, Files, etc. You can also find the Com components and Bam artifacts, but those are not in that json configuration file and we’re not going to use those today, anyway. But these are the same sections. So, jumping back to my Visual Studio project, what we’re going to do is what we need to do here first is we need to add references to the projects that you want to have included in here. So, I seem to have somewhat of a lag here between the fact that I actually… Come on. That’s what you get for running a virtual machine, I guess. Come on. Okay, so what I wanna do here is I want to add references, which is not a difficult manoeuver, usually. I’ll try plugging in the cable and see if I get us more stable internet connection.

Well, the first thing I need to do is I need to make sure that I have my references added to my BizTalk Application Project. I then need to go ahead and add those into the relevant section in this json configuration file. So hopefully, plugging in the cable will make this go easier now. So adding the reference. So I’m adding reference then to both of my BizTalk projects over here. The process and the schema project, and then I need to go up here and I need to go ahead and…I’m just hoping I will have…come on. This will be very, very slow if I end up with networking issues. Oh, there we go. So I need to give this a name. And I can give this any name.

So this name is just so when I configure my deployment sequence down below, I will actually have something to reference. I’ll name the schemas. And the second part of this is I need to give this path and that path is actually not where it can find this assembly, it’s where to place this assembly once it adds that to the package that it will create, right? So that’s my first one. It doesn’t really matter up here in my BizTalkAssembly section in what order I place these, so I could start with my process up here. And then in below section in the deployment sequence, that’s I where really add the order those things are supposed to be deployed in. So let’s go ahead and add the HelloWorld.dll as well.

So if anyone of you find me doing a typo, please don’t sit quietly and go like, “That’s going to get him later. You go ahead and join the session. Sort of one tier is I need to deploy my Schemas first, obviously, and then I need to deploy my Process down here secondly. So what I’ve set up here now is for me to deploy first my Schemas then my Process, and finally in there, my Bindings. So obviously, the Binding file that was generated for me here is empty. So I don’t wanna use that one. So what I have instead is I’ve setup a Binding file that’s already done which is this HelloWorld.binding file over here. So I’ll go ahead and paste that in so that I can use that one instead. And obviously, I need to make sure that I get that to my output folder as well.

So once that’s done, I’m ready to build this solution locally. And I’m going to go through this binding file. But what it is, again, is a received location, ascend port, and the orchestration that’s bound to both of those ports. So, once we’ve built the solution, what we should have, if we go ahead and open this in the Explorer, in my output folder over here, it creates a zip file and this is zip file now will contain my binding file. Actually, I should update that so it’s always good to check and my DLLs. So if we go ahead and go back to my BizTalk Server inventory file, obviously here and I’ll need to have the HelloWorld.binding file and point to that instead.

So now I’m curious if none of you caught that, or if you just don’t wanna help me. So we’ll see. Okay. So the second thing I said that I wanted to do here as we progressed was also to go ahead and make sure that I run unit tests. So again, I’m not going to build unit tests…oh, that’s not the right repo. That’s right repo. But I’m not going to go ahead and build a unit test from scratch, so I’ll prepare two very, very simple unit tests. One that unit tests the schemas and one that unit tests the map. We’re not going to look at those because that’s not really the purpose of the session. Just again, we’ll take that. Believe me, they work. Okay? So just to make sure they actually work locally is that I’ve not done anything wrong so far, I’ll go ahead and run those.

So as you can see, both of these tests passed here locally. So I’m now expecting those outside deploy these things to Visual Team Services that they will also work there. So at this point, I’m kind of ready to bring this to Visual Studio Team Services. So what I’m going to do is I’m going to make sure that I’ve saved everything. I’m going to go over here to Team Explorer, check my changes, stage all my files, give a meaningful comment, like “Added Application project.” I just hate when I go into my repo and I find a lot of, you know, additions that all of them have like a dot or not applicable or anything like that as a comment. So even on a demo up here, I’ll spend the time with actually putting a comment in there. So go ahead and commit those and then we’ll go ahead and sync those changes up to our repo in Visual Studio Team Services as well.

So if you go ahead and jump over then to Visual Studio Team Services, I’ve already prepared this project and I’ve prepared this repo. So if we refresh this page, what we should now have is we should now see the BizTalk Server application project committed over here so that we’re now ready to go ahead and build and deploy these things. So if I go over them to my build definitions, so this would be the place where I define how I want to build this. The very first thing that I need here before I even start thinking, you know, should I define a build definition is I need these agents. So in Visual Studio Team Services and agent is the thing that will build and deploy my artifacts.

So I do have hosted agents as well. But for this particular thing, for the building BizTalk solutions, I can’t use the hosted agent. So what I wanna make sure that I have is I want to have my very own agent which is actually installed on my server to do this. So for you to download an agent is very, very simple. You just go over to your agent section, you press the Download agent button and it gives you the availability to download an agent as well as actually define for you what you need to do after you’ve downloaded that and unzipped it. What you actually need to do is just run the config.cmd. And when you run the config.cmd, there’s basically two things you need to point out. You need to point out which project are you using and you also need to give it a token. And the token is actually just to make sure that the agent can actually go ahead and connect up to your Visual Studio Team project and authenticate itself.

So, it needs a token to do that. And this personal access token that you give it needs to have the Agent Pool authorization, just to make sure that it can connect. Download whatever work is in its queue, and then perform that locally. So Visual Studio Team Services never connects down to the agent, but the agent always connects up them and pools the cue, right? So I’ve already set up that agent. So we’re not going to wait for that install and do that either. I just wanted to show you what you need to do. So let’s go ahead and jump back to where we have our build definitions. So let’s go ahead and create a new build definition. We’ll start with the files that we have in our repository, INTEGRATE2018 that we just looked at. And in this case, I mean, you only use in the master branch.

Obviously, if you were serious about this, you wouldn’t do that. But for this demo, that’s fine. So we’ll start with an empty process. And one of the important things that we need to do here before we go any further, again, is to point out that we wanna do this on my private default agent key, which contains the agent that I’ve installed locally on our machine. So the first thing we wanna do here is we want to build a solution. And if I spell build correctly, I’m sure we’ll find something for me to use there. So I’m using the Visual Studio Build task and then I’m going to add an additional task here. So I wanna make sure that we run our tests as well. So I’m using that task there as well. Once that’s done, I wanna go ahead and publish the result of this build.

So let’s add a Published task as well. Now, these are very easy to configure. And kind of the goal of the session is not to, you know, amaze you of some complex, crazy, you know, solution that I’ve created that will amaze you or make you think I’m crazy. Instead, it is to show you how easy these things are so that you feel that, you know, you can go ahead and go back and do this tomorrow, if you haven’t done it already. So the main thing I need to point out here is I need to select a Solution file. Now this pattern here is called minimatch pattern and this will look for a Solution file to build in any sub folder. So if you have multiple Solutions files, what you can go ahead and do is actually point out a specific one. I only have the single one so I don’t really need to do that, but I can.

And then for the test project over here, I actually don’t need to do any configuration at all in this either because, again, there’s these minimatch default patterns over here. Sorry. That’s actually the one that I crossed out there, is the one that I wanna use which looks from my…something called Tests, right, which is actually what I have. So that will find it and trigger it automatically. And then finally, I need to publish something. So what I really wanna publish is actually the result of the build for this HelloWorld.Application, actually, the zip file. But I can’t really point out the zip file before I have it. So I haven’t…got to check into my repo. So I’ll just select this folder over here to start with. And I’ll call just that…give that a name that’s just the app over here.

And I wanna publish that to Team Foundation services, really the Visual Studio Team Services. So I don’t feel like publish that to a blog folder. And that’s really all the configuration that I need to do over here. I’ll just give it a name, INTERGRATE2018-CI. Now for the CI part, if I want that I can go over here to Triggers and it’s a simple… Basically, to go from build to actually continuous integration is as easy as just go ahead and tick this checkbox. So just to make sure that we fulfil the session title, we’ll go ahead and tick that checkbox. And now, let’s save and queue that. So one of the things that will happen is that if you’ve used Visual Studio Team Services in the past and you’ve used the hosted agents, you can sometimes end up waiting a while for this to happen.

But since I’m using an owned private agent, this will all get picked up and get carried out really fast, right? So hopefully, if no one’s seen me doing any error so far, this will run my unit test, which hopefully works, and it will create and publish an artifact which is this app artifact. So once we’re done with that, what we want to go ahead and do is…and it’s done…we wanna go ahead and go to our least definitions because at this point, we’ve built a solution but we also wanna go ahead and deploy it, right? So let’s go ahead and create a New Release Definition over here as well. I’ll start with an empty process here as well. Before I start, I need to add an Artifact for this.

So I need to say, “What’s the output of which build that I wanna use?” and actually go ahead and release and deploy this thing. So let’s point out our INTEGRATED2018 build, and let’s go ahead and add that Artifact. So it says that it’s located the build and it knows that it’s currently got this one artifact on here that’s called app. That’s fine. So let’s go ahead and add that. Again, if I wanna have this as a continuous deployment instead of just a deployment, what I wanna go ahead and do over here is just flip the switch and say that, “Yeah, I want this to be a continuous integration. I want to have that enabled.” Now I can set up additional filters for this like saying, you know, “If this is a feature branch, I don’t wanna do automated deploy for this.”

I might just wanna do it for my dev branch or for my master branch or something like this. At the moment, we just have the master branch and we’re going to setup any filters. So if I go ahead and go over there and here to my environments… Now, last year, when I did a session on deploying Logic Apps, I did actually have multiple environments that I deployed to. And obviously, for this, you want to have multiple environments as you actually implement this for your tests and your production environments. Again, now I’m just using a single environment. So currently, I have nothing in it. What I wanna go ahead and make sure here, again, is that for the release, I am not using the hosted one. So I wanna make sure that I’m using my particular private agent over here instead.

Now you can deploy either to an agent, which is something running on a single machine, or you can deploy something to a deployment group, which would be something that has multiple agents in it which could run on multiple machines. So I would have one agent, obviously, for one of my production service and another agent for another one of my production service. If I had that, I could set that up and add that as a deployment group phase over here instead. Now I don’t have that or I don’t want to use that. I do actually have a deployment group and we’ll briefly look at that later. You set that up in basically, the same way as you do with the regular agent. You just give it an additional parameter which basically tells it that this is the deployment group name that you will be operating in. So it will look the same.

So my default agent over here. And the only thing I need to have here in my deployment, actually, is a BizTalk Application Deployment task. So I add that and to configure that the only thing that I need to configure over here is actually where’s my deployment package at. So what I had over here is the output of my build. So I’ll go ahead and locate that file that we looked at locally, which is this, HelloWorld.Application, that zip file over here. And again, this contains my BizTalkServerinventory.json configuration file that tells it what to actually do. It contains my binding and contains my assemblies as well. So let’s go ahead and press Okay to that. And that’s basically all I need to do to configure this. So instead of New Release Definition, let’s call this INTEGRATE2018 and then we can now actually, happily add the CD continuous deployment suffix for this as well since we actually configured it that way. So let’s go ahead and save that.

So, at this point, we’ve set up our Release definition and we’re ready to deploy this thing. So before I deploy it, I wanna take one step back and actually look at again what we’ve done in our Visual Studio solution. So we added our Schema assemblies up here, we added our Process assembly up here, we told it down here, the order that we actually wanted to have these deployed in. Sorry, there we go. We also have this section of PreProcessingScripts and PostProcessingScripts over here. So one of the things that I want to do here is, I’ve set this up in a way that I’m going to actually do a file drop thing over here, eventually, right, when this gets deployed. It’s going to have an in-folder and an out-folder in this folder that it actually gets the file from the in-folder and, you know, outputs the file to the out folder. Those files or those folders don’t exist at the moment. So obviously, I could have something way more complex that I wanted to make sure that I did before my deployment. And I could also have something, you know, complex that I want to do after my deployment. So at this point, what I’m going to do after my deployment, I’m actually going to take this file and I’m going to move it automatically into the in-folder so that I don’t need to manually go ahead and bore you with me dragging and dropping files. And just to make sure we also test and make sure that the deployed application worked.

So I need to go ahead and make sure that before our deployment solution, I actually create these folders and then after I deploy my solution, I want to make sure that I move that file. Now, you might think that I wanted to add these PreProcessingScripts and PostProcessingScripts things here over here, that’s not what I want to do. So these are actually more like for you to add these resources into the application as a PostProcessingScript or PreProcessingScript. So I don’t want to use these sections, they’re not useful for me. I might as well remove them. So instead, what I want to do is, I want to make sure that I run my scripts with the help of Visual Studio Team Services. So I have in this folder actually two scripts over here that I want to make sure we run. I have my CreateFolders script and I have my MoveFile script. So we’re going to go ahead and configure these scripts to be run in our…sorry that’s actually the machine that I wanted to be in. Go ahead and run these scripts.

So to do this, those scripts are already in the repo, so I’m going to go ahead and go back to my build definition and I want to make sure that I bring those scripts from my build over to my release. And to do this, I need to make sure that I’ve published those scripts as well because I’m not publishing those at the moment. So I want to go ahead and go over here and add another publish task, publish, just to make sure that we have our scripts available as well. So the path then I wanna going to publish is an [inaudible 00:26:51] repo, I have the Scripts folder, so I wanna go ahead and publish that. I’ll call it Scripts. I’ll add those two TFS as well. So let’s go ahead and save and queue this build so that we actually have our scripts with us to our lease definition as well. The second thing that I want to do is I want to utilize those scripts as I do the release. So I want to make sure that before I actually deploy my application, I want to create those folders. And then after I’ve done my release on my actual BizTalk Application, I want to make sure that I move the file. So let’s go ahead and go and edit this one. So if you go over here to our pipeline, what I want to do is I want to add two tasks. So I want to add a partial task. So I’ll add that one, and I’ll add a second one.

So for the first one, what I wanted to do is, I want to trigger my CreateFolder script and then for my second one what I want to do is I want to go ahead and trigger my MoveFile over here. So at this point, what we’ve configured is a way so that my agent will first create the folders for me using this PowerShell script, and not… PowerShell script is really, really easy as well. It’s nothing complex. It just creats two folders as far as the MoveFile script, it just moves the file that we looked at into the input folder that the CreateFolder script will have created. And this should make the intuition actually trigger and move the file to the output folder once it’s gets deployed. So let’s go ahead and save that. And now hopefully if, everything is configured correctly, what we have over here at the moment, if we refresh that, is we don’t have this application over here.

So I want to make sure that we go ahead and release this at this point. So let’s go ahead and create the release for this, which will trigger the agent, hopefully, very quickly. And again, since I am running my own agent, there’s no queue. We hopefully won’t have to wait for this very long. This should all trigger very quickly, should, in theory, any moment now. Let’s go ahead and make sure that I’ve actually have the agent started if nothing else, just so we can wait on it actually getting started. So I do have two agents over here. One of these is my regular agent over here. And the other one over here is my deployment group agent. So you can have multiple agents installed should you want to. So hopefully, having looked at that, this agent should have started. I could probably just refresh it. Did you spot an error?

Man: No, no. You just need to refresh it.

Johan: Yeah. No, no, patience. It will get there. Supposedly, it has started since I cannot cancel it so, come on, pick it up, pick it up. I’m going to wait for it. Mike gave me a couple of extra minutes. So I have time. So we could look at just not looking at that for the duration while that deploys, is we could go ahead and go to our deployment groups over here. And I can show you what it actually…if you want to create a deployment group instead, what you want to do is you want to go ahead and just add new Deployment Group over here. So let’s call that Test. Okay, Test 2, I would give you actually, all of the partial scripts that you would require to go ahead and install a Deployment Group agent on your machine. And you could also tick this checkbox over here, and it will automatically create a token for you as well. So you don’t have to go ahead and do that second thing. So when you actually copy the scripts that will be something that you could just paste into a process prompt on your machine, run it, and you will have the agent up and running, all right?

So hopefully, that will have given that time and if that’s not the case…come on. I can cancel it. I’m going to go ahead and do this, see if it helps. I shouldn’t need to do this, but I’m doing it anyway. If that doesn’t deploy, this is going to be a sad demo.

Man: Pick up the [inaudible 00:32:23].

Johan: I can view the queue. I should not need to actually do this. Right, it’s queued. So it should go there. While we wait for that, which is, you know, we could go ahead and look at the second thing that I wanted to do. So if you go ahead and jump over here to my project, so one of the things that I have over here is, I have my binding file. And at this point I have a single binding file, it has all of the pieces of it hard coded, which basically means that it will, you know…I realized I’m breaking one of Richard’s rules over here, when I point out something in C:, but hey, it’s a demo, so I might get away with it. So, but I might have also have different folders and different configuration that I want to have for different environments, obviously. So what I want to go ahead and do instead for this one is…and I don’t wanna use a hardcore to the Binding file over here. What I want to be able to do is I want to go ahead and…sorry, from that folder, I want to go ahead and use this tokenized Binding file instead over here. So let’s go ahead and paste that in.

So this tokenized Binding file is different in the way that instead of having a hard coded path over here, it just points to my out folder for my Send port and for my in folder for my Receive location, right? So and these are variables that will get super substituted as I do the…hopefully, do the Visual Studio Team Services release. Okay? So and to have these substituted by something, I need to also enter these in my Release definition in Visual Team Services. So let’s go ahead and update my BizTalkinventory file over here to actually…instead of using HelloWorld.binding, we’re using HelloWorld.binding tokenized over here. And let’s make sure that this is also copied to the Output folder and let’s build the Solution which should be fine and release. And let’s go ahead and go over here and make sure that we stage these changes, tokenized. And we synchronize these up to our repo. So what I now have instead is, I’m using this tokenized file, and as I’m using these tokenized file, what I also need to go ahead and do is you need to go ahead and update my Release Definition to actually contain these variables as well. That took it long enough, didn’t it? Anyway, so happily, that’s running. I’m not sure why it took it so long. And I’m a little bit curious as I need to deploy a second version of this soon.

So I’m hoping it’s now warmed up and will be happy to comply with being a very fast thing. It usually is, so I’m not sure why it wasn’t this time. I can’t really blame the WiFi or anything like this, since this virtual machine is an Azure and we should do Team Services as an Azure or at least it’s in the [inaudible 00:35:55] Data Center. So, I don’t know. Anyway, so let’s go ahead and edit this Release Definition over here so that we enter our variables over here. So I’m going to add the variable that was called the in-folder. So and I want to give that a value. And just to make sure that I actually get it right, I want to go ahead and…so it’s not actually…you can see that the release has run here, because I now have the in-folder here and the out-folder here. So if I’m happy, so I know actually…this actually shows that my first release was successful because it has now created these folders, run the CreateFolder PowerShell strip, deploy my basic application, and then actually moved the file. So I’m now getting away with doing a file demo, but it’s automated. So that’s one step in the right direction. So we’re going to look at how the logs look and a little bit of that as well. I just want to finalize these parameters first.

So again, let’s go ahead and make sure that we get the correct folders so that I don’t misspell or anything like that because I’m sure you guys won’t tell me. If I do, you’ll wait for the chaos. So let’s go ahead and… Oh, here you go. Thank you. So I now have these parameters over here. That’s my in-folder, and my out-folder. So for this, I could have a scope. So at this point, I only have one environment. But if I did have two environments, I could say that, you know, this is the configuration that I wanted for the first environment let’s say, test, and this is the configuration of wanted for my second environment, let’s say, prod, right? But in this case, you only have the one but I can set the scope so these will differ. So you have those there. So since I do actually have automated now this process, with continuous integration and continuous deployment, what should have happened as we actually went in and configured these things, I did commit my changes with the tokenized binding file. So, probably at this point, we’ll have a build that’s been triggered. And then we’ll have a release that we’ll have tried to triggered, but at this point, we haven’t configured…at that point, rather, we hadn’t configured these parameters yet. So we’ll have failed, which is, you know, what I believe has happened. So we’ll go look at that.

So again, for this INTEGRATE2018 here, you can see that, you know, the first release that we could see in our folders that actually succeeded, that used the hard coded paths. So that succeeded. But the second release over here that was actually triggered by my commit, build, and then tried to deploy, that has actually tried using this tokenized file. And at that point, I hadn’t configured those tokens yet, so we’ll have failed basically saying that, you know, null or empty parameter over here in-folder. But at this point, I have configured them, so I can go ahead and go here and trigger a new release for this. So the build is already done. I can you reuse the last build I did. I don’t need to trigger a new build, but I do need to trigger a new release. And as I do want to wait for this to complete, I’m now hoping that, you know, they would go in progress so that’s what I wanted. I’m not sure why it did that thing the first time, but since I have my own agent, this will be very quick and my PowerShell scripts are, you know, handling the fact that these folders already exists and it will handle the fact that it will move the file again as well.

So this will actually complete and run, I’m not going to force us to wait on this thing either, but it will build and it will complete. It will do basically the same thing, moving the file from the input folder to the output folder. And as you can see, it actually already has, right? Because I’ve now got two successful builds over here. So just to make sure that we can see this over here as well let’s go ahead and refresh the thing over here and we can see that we have our resources deploy here in BizTalk as well, and it was done through obviously my release definition, Visual Studio Team Services. So with that done, what we need to add from here, I mean, what does this actually bring us? So it brings us a place to start, right? It’s not a magic thing. It will not get us all the way to what we want to do. We will need to do a lot of PowerShell scripting, just as in the past, for ourselves. We will need to do some counter binding for handling by ourselves. I mean, obviously, we can configure and use the features that we now have supplied through this basic application, deployment tasking Visual Studio Team Services, but we still need to handle those things on our own. And doing that through variables and Visual Studio Team Services might be one way, there are others.

So again, there’s a lot of resources out there like BizTalk PowerShell Provider, the REST Management Endpoints, which is also something in Feature Pack 2. And obviously, all the old stuff that’s been there for a while with the WMI interfaces, ExplorerOM, all the executables that’s in the product and those you might have built over the years yourself, as well as all the…if you use something like BizTalk360, that also has a lot of REST APIs that you can use from PowerShell and in your deployment tests as well. And obviously, you will create a lot of your own PowerShell scripts as well. Right? So with that said, some kind of summary. You know, it’s always a good idea for you to automate things. It doesn’t really matter if you build a release process, or if it’s something else, automation is good, right? And it’s not limited to using Visual Studio Team Services, I’ve used a number of different tools in the past and a bunch of you probably have as well.

So the concept of what we’re doing here, it could be applied to other tasks and technologies as well. But for this, we use BizTalk Server Feature Pack 2 functionality, right, which gave you these basics of application project. But you still need to create things on your own. This will help you get started if you haven’t already, and the community content is there to help you. So if you do have any questions or any follow ups, I’ll be here even though it’s a holiday for the rest of the day, as far as these contact details and well, Twitter as well, I didn’t enter that in there. So, thank you.

Download Presentations

Fill the form below to get all the presentations delivered as a single zip file in your mailbox.

please wait …..

Interested about future events?

please wait ...