[Music] so i like to boil a conversation into one slide because it's so much easier um there you go yeah so this is how i explain app services it's part of the wizard right yeah but i got all the drop downs there all the different types and i explained that you know these two types require licenses right which is also in the in the description and i i put these uh decorations around here gotta provide some guidance because a person may not know what they're doing and why when they're just sitting there looking at these options gotcha yeah and i think the key thing you and i have some conversation right is that the point of application service is that it's a logical construct right yes such that the whole point of the application of this wizard was you first start off registering the application service yeah right and then you may or may not actually ever have a map underneath it right right so that's the starting point and then seconds like when you register it like you were sort of giving you a unique id so that you could actually make some of the tagging easier right because these are really kind of more or less sort of targeted deployments target environment like whatever you call it right it's like a target deployment is kind of what this application service really is right if you think about pure id terms right so other things obviously it's gonna be different so that and then the the process you're like you you have some process of saying like when do you actually create a new deployment target you register that deployment target right you get a unique id for that deployment target you put it in you know with an api cli wherever you want to deploy it right and then now that data is there in your environment so now if you want to change let's say the priority of that thing or the name or the who the ownership is or whatever not right you can just do it in this one place as opposed to crawling through your entire environment saying like oh this is now more of a a production oh no i changed my compliance where now this became something else right or more you know kind of usually it's like oh it's now owned by somebody else that's right so that was kind of the point and then once you sort of do the registration you know you can come back you know now or later in terms of building the actual ci yeah or the map of what is it actually in terms of the underlying infrastructure that's really serving that right and the key there is really about people ask me all the time like why do you need that right and it's really about when things don't work or when there's a problem the way to get that business context is using here's my you know business application which with all sorts of you know information object talking about compliance and everything else it's connected to you know n number of my application service which are actually my deployed kind of product you know providing that service and number three is that now if you want to manage okay this server is down or this container is down or this function is down by having the application service contacts now you have a really easy logical way to say like okay this is serving these x number of things this is who owns it in terms of an application if you don't have that then you end up just having you know one physical thing like a tag right essentially would be like oh i'm going to create a server in the cloud and i'm going to put 50 different things in terms of tags i have because you're putting all that within individual things and war said you're having to iterate that every time anything changes right that's right so again so this is really about logically putting it these are a bunch of things that are related to each other they're serving this purpose related to this business application making that easy right that's right yeah and then the the next thing i'll talk about that there's a lot of confusion that i'm hearing recently is really on dynamic ci groups as well as sort of uh you know dynamic services right so i'll talk about a little bit about the gotchas there so dynamic service is something that's new that just got introduced what it does is it's gonna build that application service in terms of here's my you know entry point right and here's all the things related to it by looking at the cmdb itself so it really goes and looks at you know this server is connected to i don't know you know you know you can define the levels you want to look at right and the relationship you want to follow in terms of building that that that you know these are the things that are you know related right as an example i can talk about it from a dependency view perspective a server could be connected to every other server like that's you know hanging off the same load balancer right but does not mean that they're within the same application service which is like am i sort of grouping them together to provide a logical value right etcetera etcetera so given that what you can do here would be like you will go define these are the relationship i want to actually follow from my server that's connected to other servers of this and also a load balancer that has other servers connected and you can use that to say based on my ci relationship this is how i'm going to carve out what is actually part of that application service yeah so so basically we have the service map which is a view of a i would say instance of an application or a deployment of that application you know whatever you want to talk about and and it takes a very specific path through the seem to be yeah versus show how everything's connected to everything which is what the cmdb does show so it's more of a top-down perspective yeah yeah yeah and what dynamic service lets you do is it will let your right hand side it will carve out what the actual service map looks like based on the relationship and the levels within your ci right that's one second is that you know sometimes customers actually want to build a service map manually right or ingest it from somewhere else and the easiest way to do that would be just you know leverage the dynamic service yeah so for customers that have built manual dependencies in using the cmdb um this this would allow them to bring it in and see it in this way yes as a service map yes and whatever changes you make is automatically reflected right so tomorrow let's see you add another server on the bottom right that's going to show up in the service map automatically got it got it i would sort of recommend that you really should be the way to go as opposed to doing the manual you know select ci one by one which is the option ahead of it right so i would say like that really is more or less something you should avoid doing and rely on the dynamic service instead yeah there's no automation there right it's just you know one z two z three z cis and that's it yeah exactly exactly and again anytime you change anything in cmdb you need to come and manually change this right which is yeah net net you should never potentially never use right so that's kind of warm and the other one i want to talk about is actually dynamic ci groups right so dynamic ci groups there's obviously a couple of places where we use it and then the construct is really about like how can i dynamically again as the name implies you know and i know there are a bunch of dynamics here right but this one is really about i am going to define some kind of a you know a pattern and based on that pattern i'm going to group certain things together and the pattern could be like hey a customer wants to do some kind of a mapping of all the things related to an application right the example we just talked about but let's say you know for whatever reason they can't use like tag-based mapping or top-down mapping so this option uses say like okay all servers you know starting with the name mark application are part of this environment so as things come back and forth you know saying you know mark application it's going to build that list yeah so so basically if you could define a query criteria that criteria will populate this so i know i know when i used to work in it we had a naming convention for the server uh when when it was allocated to the pro application that it was going to be running on it right so we have we'd have a very specific naming convention that's used so if we had that we could use that as the query and it'll pick up all that and put it in this exactly exactly and again you can actually also use if you have tags defined right you can use the same thing as well okay so again anything that is and the difference between that and tag-based mapping is like tag based mapping does more in terms of actually connecting building relationships right and much more of a complex thing in terms of defining all the potential groupings you have this one is you know free but also you know more simple right which is exactly like you you have here it's really like i have some pattern i can define i can group things together right yeah yeah and you can also throw some manual things in there if you need to as well right 100 yeah and then one thing i also address is that i get a question like how do i see these right and the key is like whenever you are in a dependency view if you click on these things it will show up in i think the detail list as like the servers within this dynamic group yeah or if you're in service mapping you click on like you know the actual application service you will see them as a flat list right so what you don't have here is that ability to sort of see all the connections you know between the ci's here because again they are more or less a flat list is kind of how we've defined them right right so so it is since it's a query right you could have a hundred thousand things in there yeah yeah now there is a limitation on using query builder though only 10 000 results will show up is that right that is by default yeah so you can go change that property to make it whatever number right okay but our feeling is like you've made something really wrong if you have more than ten thousand for a cmb group yeah because again the whole notion is to kind of and even for the biggest of big customers i've never seen a application service or any other grouping with 10 000 things right yeah yeah that's usually not the case yeah yeah exactly and the key would be like you know even if you think about like the most prevalent thing would be like okay laptops within an org yeah the company and even that i would say like hey you should sort of break it out by is it windows or is it mac where look where is the location is it emea us whatever right so the key is like you can change the 10 000 but i would say like you're doing something wrong if you actually need to change that yeah so you could use location as a way of breaking it down or let's say the product model it was a different model like a mac versus a window intel exactly exactly exactly so again so they're definitely intent wasn't to have like one giant group right that's that was not the intent and the second thing here is these dynamics ci groups can be two different types right one is like they become quote-unquote and application service themselves like in yeah right or they can be something logically used a lot of times for you know connecting to something like uh you know a technical service offering yeah right we talk again we yeah we talk a little about it so we so is when you're creating the app service you can use it within the uh as an app service right kind of exactly and then coming back here we can use it as part of the technical service definition exactly exactly and it just sort of automatically insert creates a different type in terms of the classification if it's for you know application services or for dynamics or you know ci groups right but the underlying technology is the same it's just like based on that classification you know you use it for a little bit slightly different purposes yeah makes sense and and here you can connect a business service offering to directly to it or technical service offering here that's not really what was meant when we created it here though right i mean it's a little bit different yeah yeah it's still a bit different yeah yeah and this is really about like the key things we did here was having something that is a logical grouping but something that has is a ci that you can attach to a bunch of different processes right like change like incident and so on and so forth right that was the notion that we didn't want to create the same technology twice or you know have two of the same tables with different labels right yeah i i i also talk about remember we used to have event management who had their own query mechanism so event management defined their own version of technical service the query was sort of in there yeah and it was it wasn't really a ci type right only event management used the thing but now it's part of the main stream structure so everybody can use those queries yeah exactly exactly so the one other thing i definitely want to call out for application services right is that there are limitations in terms of what you can do especially when it comes to you know number one you know mixing and matching you cannot have a single map that's based out of different types of application services yeah so we call that um mutually exclusive you have one or the other you can't you can't match them yeah what still works would be like you can still have like a nested application service right which is how we deal with essentially any kind of micro service architecture whereby yeah you can have my authentication service is actually based on a tag-based mapping right and i'm using dynamics ci group for another piece and i'm doing you know service mapping for you know top-down mappings or another piece they're all tied to a parent you know application service that is fine but what you can't do is have one application service with data from multiple different things yeah yeah so so when you're defining a new app service you can choose its parent and that will set it up as a child right and as a result yeah yes now i noticed that when i choose parent that it does go through a process of setting up a dependency really it's um uh so i don't i don't know if if that's the way so this sets up all the relationships for me so i don't have to go into ci the relationship editor i can just go into uh into this wizard and it's and it does it for me i don't have to worry about what relationship to choose and all the right relationships are chosen here yeah and under the covers it also does enough of the things so you don't have to worry about like service mapping either yeah right so if you show up in service map and you've defined this here it will show up as like here's a child service right within that map that you can go through as well so so when you're setting it up you choose let's say the parent and you look at look at the parent it'll it will traverse and also include the children that it that it it's part of that it has it has if it has a number of children exactly okay cool so so if you come in at this level of the service map it's this far down and then if you at the higher at the parent level you see the children exactly got it very cool and the final thing on the dynamic ci group is like i get some question in terms of like i think can i have a tag-based mapping as part of my you know kind of dynamic ci group yeah and the answer is no okay right you cannot and it's really like logically you know it would just show up as just a singleton table and it's not going to understand anything in terms of oh this is actually you know not just a single record but it's actually a a live map underneath it it has it does not have that context okay so what if i take an encoded query though or a query builder and i actually query based on the tags so it just gives me the list of stuff right there's no structure there or that's that way there's no spectre yeah you just get a flat list of everything that match whatever query you made right you can turn that into a map but it does not have like i mentioned right uh nice like a relationship with each other right but the other thing i was saying is like maybe a different example right you cannot have a top-down service map be part of your dynamic ci group application service definition right so if you have that scenario you want to sort of create a parent-child relationship right within the child and not try to build a map within you know the dynamics ci group i see so don't have your query query another dynamic city group exactly so all right so you so you can't do that um yeah okay like i said the process is really that you create an application service right you register that thing right and that start off starts up as like a really high level service auto is like a table name right like that's like the highest level app service and once you pick a method it will go into a sub category of that application service table right and for us we really want to make sure users sort of are sort of thinking about you know registering and filling things in not super worried about like what table should i look at and you know those things should be like kind of you know hidden from a customer perspective yeah because i mean the with the nice thing i've been telling customers is use this wizard to define it don't worry about the table because different versions different versions may use different tables and uh depending on what what deployment they have exactly exactly yeah and it's like well what should i use i mean in csdn we do talk about it here but obviously um yeah with all these different options people are kind of a little bit confused but we exactly the main thing to know is this one exactly so we created this setup right this it was just so you know we don't want some of the technical reasons why they're different tables to be how customers think about it right they should really think about how do they want to build this up and not care about what table is it going into yeah so what is your advice for customers that are doing imports from other systems i mean because one of the things that i've i've had to deal with is um customers are they're saying okay mark i i've got an old remedy system or or whatever and i'm now gonna gonna populate this model by from from my remedy data should they put everything in the auto tube or i would recommend a lot of third-party tools i would recommend using service craft connectors right yes so that's i think for good reason right but again but if you can't use that you want to do your own well yeah but these the a lot of the folks i'm talking to they're just they're getting off of an old another system right another spot so the way i would think about doing this is really you know leveraging kind of dynamic service you know that i mentioned we just talked okay okay which is really like i am going to bring in all the relationship how things are connected to each other using ire using igtl and building that relation tree out right and then depending on whether you've already defined you know in whatever tool what that application service is right just create a dynamic you know service for each one of the things that that's the top level entry point for those yeah right okay and if you do that it will automatically build out whatever's underneath that and they'll create you sort of the service map with the least amount right okay and if you go change that you know it does the same thing and and the net is like all the service graph connectors that are building them bringing in maps do the exact same mechanism right okay where we sort of bring in the cn relationship we define that whatever application service other you know the other tool had and that becomes the entry point and then this service map is automatically generated right okay well that certainly helps um it makes a lot of sense too and why we added it it was it's probably well over two people trying to do this without it i can't imagine yeah that was the number one ask feature in terms of the the wizard was like hey can we add this in there right we actually do have or did have apis available to kind of do this already right it just wasn't exposed cleanly right yeah and then so this is the kind of what we did you know if you look at our business service migration to app service yes right the underlying mechanism is exactly this right but now we're exposing this because we see a lot of value in terms of just building a map instead of just you know converting you know a business application you may have had in the past that are sort of you know you need to migrate to a application service to follow well that's that's good to know too because if they do have let's say they got a situation where they're only using business services they're not using uh technical services or any kind of app services they can basically do their own conversion by creating these i guess porting them in even on the same platform on the same instance it's even better right so if you actually have a business service and you open in a list view right there's a little option saying convert to application services right and this is really helping customers who business services that are actually you know on a cst and you know technology should be application service right yeah so for those you don't even need to go do this you just go to that you know uh you know this form go click on the actual business application right and it will convert that into an application service right and fill in whatever data it had on the bottom right just like what dynamic service does that's right yeah again that's that's the way they should do it if they already have it in business services and it sort of has the right connections yeah so it's already on the form it's in the upper right yeah it's been there since i want to say london maybe um it's been there a long time for a while we've made it a little bit better recently in the sense like it is dynamic now right seriously it would do like that one time and if you could change your cm maybe your service map wouldn't change unless you like said recalculate or you know redid it but now you know you have a choice of just making it dynamic right so as the cis change your surface map will also change interesting okay so so the automation that happens in the background is now there so it kind of preserves the map as ci's change which it didn't do that before so is is that enabled by default or somebody have to go and turn that on it is enabled by default all right all right well cool anything else you can think of i think we covered a lot of ground here so final topic there are definitely limitations why don't you pick a method it is converted to a different method yeah right so you can't change your methods after it's created customer right for their application yeah right there are some workarounds around it but again the key thing i would say the recommendation would be like if you need to redo it just create another application service build that out and delete the old one right so delete we recommend every time we get sometimes buffers want to preserve yeah so delete or retire my general recommendation is like you know it's not worth that i see yep makes sense all right have a good weekend take care bye