How To Containerize a .NET App Without a Dockerfile

the dotted platform provides great support for running the net applications as Docker containers via the docker images published by the.net team however the way you build those images via Docker files has always been less than ideal because it does not take full advantage of the.net build process so today I'm going to show you the new way to build.net Docker images without using any Docker file let's start to demonstrate a new way to build Docker images for.net applications I have prepared a super simple rest API using the default web API template that comes with the.net SDK and just keep in mind that what I'll show you today we can available with version 7 of the.net platform so you'll need to install the.net7 SDK or grader and in fact let me show you the version that I'm using today so here I am in Visual Studio code with my product reader in with my terminal and altus2.net version that's going to show you that the version I'm using is version 70200 and if you take a quick look at what this project does and if you just close this terminal and go into program CS for a moment you're going to see that all it is is that we have this one uh weather forecast endpoint that we can invoke and it's going to return a random list of weather forecasts based on this list of summaries over there on the top and then a set of dates a set of temperatures and something some calculations in there all right and so really really simple nothing uh no rocket science going on here um now one thing that I did here is I did comment this line here up use https redirection just because we're not going to be using https for this demo and to avoid a set of warnings that could show up over there okay and so let me show up my export over there and then let's go ahead and actually start the server so I'm going to open my terminal here and let's switch to helldalker.api which is the directory where I actually have the project I created and I'm just going to do.net run so that's going to start the server and that's going to show us where the API is running it is running at localhost 5073 and how we're going to test it well there's a few ways to to test this API these days but the way that I really like these days is by using this risk line extension it's an extension available in BS code let me show you if I open my extensions view yeah right there just look for res client you're going to find this extension a risk line by when Chao Mao right here is a great extension allows you to do all sorts of testing of apis directly within BS code which is why I like it right so let me close that let's go back into hello docker.api and actually let's go into this file that I have here hello docker.http and uh in this file what I can do thanks to that extension is to declare any of the apis that I want to test in this case I'm undeclaring here uh get request for the location of my server and at the location of my weather forecast API all right and let's make sure that my server is running yeah it is running let me cool after this for a moment and what I'm going to do is just go ahead and click here on send request and as you can see on the right side we were able to retrieve the results of the vocation of that API so you can see we're getting a 200 okay and we can see a random list of a weather forecast and so what I want to do now is to actually turn this API into a Docker container because of course we want to deploy this into some sort of a server either in our local network or in the cloud or even in kubernetes uh so Docker is the best way to take this and get it deployed very quickly in the best possible way so how we turn this into Docker container before I show you the new way to do this let's let's just do it very quickly at the classic way of how you would do this via a Docker file so let me just go ahead and close this and let me open my terminal to stop our server yeah it's stopped right now and then let's show the Explorer right so let's collapse this and so the way that we do this is like I said with via Docker file so how do we generate a Docker file in business Studio code very easily uh if you have the docker extension installed by the way let me show you that too just type Docker here are you going to find this extension by the docker team is the one that is going to allow or enable all of the tooling that I'm going to show you right now all right and so all you have to do is just go to the common plate and you're going to say docker add Docker files to workspace right there so you're going to pick a platform in our case it is infinite core uh we're going to create it for Linux because it's super fast and then here's the port that has already been defined for our server so it was able to recognize it so that's good and then we want to use the compose file Docker compose not really no not need it all right and so right away Visual Studio code scaffolded this a file here a Docker file which is the one that describes exactly how we're going to be building our a Docker image for our application right and we're not going to go into all the details of this file but just let's take a look at it very quickly just to understand what's going on here now this file supports what is known as multi-stage builds in Docker and so because of that there are a few stages right so this this first section over here from line one to ten is the first stage and the main thing about this stage is that with here we're deciding what is going to be the image on top of which we're going to be running our application and as you can see at the very top we are choosing to run on top of the.net asp.net70 local image which is going to make sure that we have all the dependencies all the files all the configurations that are needed for any asp.net core 7 application as it is R1 all right so that's the main thing about this first stage and then we go into the second stage down here here from line 12 to 18 in the second stage we are actually switching into another Dockery mesh where we say okay so before we can run the docker image we have to build it right and to build it we're going to go in from another image which is a.net sdk70 image we have to switch to this other Docker image because this is the one that includes all of the build tooling so that you can build an application not just run it but build it right which usually involves more files right it's a bit bigger and but it's the only one that allows us to have all the tooling required to build application so all of this happening here is just copying files into the docker image and then restore independencies and building stuff so that we end up with the actual a compiled application okay and then we go from that stage that will stage as you can see in line 20 here we go from that stage into another stage called publish we're just renaming it as publish right and we're always doing is just publishing the the image in a shape that's ready for running it right to run the application right and it's going to end up in this app slash polish directory it's called also going to be in the release mode right because this is no longer we don't need the Box symbols we need a release version application here because this is for production and then finally we go into this last stage at the very end here which actually starts from the base stage over there which is we're saying Okay so let's go back into as a a stage where we can run the application not build it but just running which is going to be a smaller and leaner image right and let's let's treat that image as our final stage let's say is our final stage and then we're just going to be copying everything that we created in the previous stage in the policy stage is going to be copied into the root directory of this image and then we just go ahead and run the application via the dll that was producing right so this is a Docker a Docker file that is able to both build and run the application as required and so well how do we use it how do we actually build the image out of this so let me actually go ahead and open up my terminal once again and I'm going to clean this and the way to build a look at image as you might know is by just using the docker build tool right and so by the way I do have a Docker desktop installed in this machine so make sure that you get Docker desktop before doing anything like this because otherwise it's not going to work you need to address up in your box so I'm going to say Docker build and then you have to divide the tag for this build which is composed of the name of the image and the actual tag so I'm going to say Dash D let's say I want to name this um hello docker classic okay and then for the tag we're going to set this is version one zero zero right just as simple as that and then lastly we're going to put a dot over here because this is the build context right so this this defines a words that we're going to be building things from so I'm going to hit enter and I should go ahead and build our record image now however as you can see here we do have an error right here right he's saying well I cannot really copy the file and in fact if we look at it down here let's look at this entirely like that uh you can see that yeah we cannot find the the file this is Rock file so what does that mean well if we take a look very quickly we we go into the Explorer view over here and we collapse this for a moment notice that as we go through our Docker file uh the file at the generated file is trying to copy from Hello Docker API hello Docker API CS block into its own directory right however this is happening from a Docker file that is already inside the hello docker.api directory right so when when the docker file tries to to dive into a hello Docker API directory it gets confused because we are already in that directory right it should not be like this right so this this sentence here was a run generator it will make more sense if the docker file was at the very root of my direct MBS code director here I'm not inside the hello docker.api and directory and this is one of those things that starts making you think if if using a Docker file is really the best way to produce your Docker reviews and of course what you're going to do here is usually just move and move out the docker file but another thing that you can do is actually fix it so let's let's go ahead and fix it very briefly because it's not not that hard so what you want to do here is just modify this saying well you don't have to go into hello docker8.api directory just remove this like that and then just copy the helicopter.api file that you're going to find right there next to the docker file and also this sentence here on line 16 is not going to work because it's going to again try to copy everything from the current directory the hello Docker API directory in my box into the SRC directory which is worthy right now right which is not going to make sense it should be copying things into dot slash and this director here hello Docker API which is the one that Delete where it copied the project file okay so just by making this change here and this other change over there we should be able to build this Docker image now right after fixing it so let me collapse this now and let's go back into our terminal let's click this and let's run the same sentence again right so Docker field let's see how this goes and as you can see things are moving uh forward nicely now okay and what's happening here is that of course it is a Docker is downloading the image the ESPN 7 image and the SDK sending image into my box and then it builds the application using the stages that we talked about right and so at this point if we just clean this and we say Docker images we're going to see that we do have our hello Docker classic version one zero zero image right there and if you want it we can go ahead now and run the image so to run that image all we have to do is just say Docker run and then we're going to do an interactive session just so that we can easily stop the application when we're done with it we will do our M so that the container is removed after we we are done with it and then we have to see if I also a port right to tell how is that we're going to access the application that is running behind the scenes right and so in this code in this case as you know as we specified over here duplication is going to be running import 5073 inside the docker image right so what we'll have to do is to map whichever Port we want from our box or host machine and into the docker image so in the docker image the port is going to be 5073 and then we have to decide what port to use uh and in the in the outside right so we could put really any port any valid Port here but just to keep things simple without using the same port 5073 that day a process is using inside the local image right it doesn't have to be but it just makes things a bit simple and then we have to pick the name of the image to run so that's going to be hello docker classic and then the tag which is one zero zero and that should be it let me go ahead and hit enter and as you can see we are now running a our Docker image within our Docker container and you can tell that because as you can see here we are now running in a production environment right and then you can see here we're running in uh in the in localhost 5073 right and so just to confirm that things are working properly what we can do now is um let's go to Explorer and let's open hello docker.http once again and let's go ahead and send requests it should be the same port so same request and if we can see on the right side we are able to retrieve the the weather forecast just as before right so the application is working properly we are able to access the the application that is now running in the docker container not in our box but really in the docker container okay so that is great and let's just close this and let's just stop this hey for a moment now uh so that's that's working okay I mean it was not great that we had to modify the docker file to start with it should just work but okay so we modify things and it's fine but now let's go ahead and introduce something else so let's say that now we have a requirement to introduce a brand new component in their application right and this is going to be a component super simple that's able to track metrics for our application right so this have to be this has to go into another project file right so let's create that that class very quickly it's going to be super simple but I want to show you one thing that happens when we when we do that so let me close the docker file and let me open my terminal here and let's uh jump up and then let's create a brand new project so it's going to be but the node is going to be a class Library and let's name this one hello Docker dot telemetry all right as you can see on the left side we have our brand new hello Docker that Telemetry preview created right there and then we have this class one class generator which we're going to rename actually into something else it's going to be named metrics emitter all right that's going to be the class name let's put this class name over here all right this is going to be actually a study class to keep things simple and and let me go left this this is going to have just one method let's call this method public static void count they say that this method is the one that they're going to be able to count any metric that we specify and the name of the metric is going to come here so metric name all right and so to keep things super simple all we're going to do is just say console Dot rightline and then we're going to say counting metric and then this is going to uh let us pay set space for the actual metric name which is going to come as a parameter over here okay so super simple and just for fun let's just change the color of the console so that we can see better in inner console so let's say console Dot foreground color is going to be consolecolor Dot green okay and then after we're done with this we might as well also reset the color so let's just switch back the color into whatever was it for and so as you can see super simple method all it does is just simulate that it's counting a metric so now we want to use this method and this class in our API project right and so let's show the Explorer once again what we want to do now is to make get a reference between from the API project into our Dynamite project so I'll open my terminal here let me switch into hello docker.api here and all we have to do now is just say.net add reference and then we're going to go into hello Docker that Telemetry and hello Docker Telemetry CS Pro right so that adds a reference and with that we can now let me just close this and let's go into program.cs let's see can we close this yeah let's close that and then move here now what we want to do now is just say Okay so after we return the set of forecasts what we want to do is just uh well do the count right so in this line here we're going to say metrics emitter Dot and of course we'll have to do control dot here to use hello docker. Telemetry Matrix emitter dot count and then the metric name let's say it's going to be weather forecast request okay that's all it is so that's our awesome metric so with this in place let's go ahead and test it let's make sure that we can actually count this Matrix right so let me open my terminal once again and perhaps make it smaller like that and then let's just do the net run once again all right it's running let's open up our hello docker.htp file over there and let's go ahead and send a request as you can see we can still get the uh let's make this a bit smaller actually like that we can still get the the word forecast but more importantly we are able to see the the effect of our metric counter right there okay and I can make a multiple requests as you can see and it will keep saying that yeah we're counting the mat so this is working just fine as expected okay now let me close this and what we want to do now of course is to produce a brand new version of our Docker image that includes this new functionality right because it is the next version of our application so just like we did before we're going to run pretty much the same Command right so it should be Docker let's go back into Docker build right this is the one that we used before um we should be able to use BUMP the version into version one zero one say this is the the new version and uh yeah and in fact let me make this a bit bigger and let's go ahead and build this image and see uh see how that goes okay so yeah so you're trying to build the image but this doesn't look quite right right so let's see as you can see there is some sort of an error going on over here but we will not we were not able to run the build operation and if we keep going down we can see that the build actually failed what else we got here if we go up we're going to see that yeah so look at this it's keeping the project uh he cannot use it because it cannot find hello Docker that let me do the Cs block right and so if you think about it well that kind of makes sense uh because if we go back into our Docker file so let's open our Docker file over here notice that we did copy our hello Docker API CS proc but we never copied the Telemetry project right so if you go back into Explorer we never copied hello docker.lamic DCS block into the docker image so it doesn't know about it and furthermore it doesn't know about any of the files that are required to build the Telemetry project which is a dependency of the hello Docker API project right and so at that point you have to start thinking okay so sure I mean I have to copy that so perhaps if I do something like this I would be able to they okay so hello hello look at that Telemetry right so I want to copy this into hello Docker dot Telemetry inside the the docker image but then you have to realize that you're not in the content in the same context as hello Docker that Telemetry right so now you are I mean you are in a directory inside the local API you have to get out of hello rocket API and then into hello docker. Telemetry so perhaps something like this to get out and then go in but that's not going to work quite well because you have to always operate in the context of the in the docker build context right so that's not going to be really really easy uh there may be I mean there are ways to make it work and usually what you will do at that point is just take your Docker file and and take it out one level up right at the root and then you start to start you need to start a scaffolding new lines here to copy your order like in this case it's limited project and then also you will have to do something here in this line 17 to also copy all of the other files right and then set the proper word there and you you'll have to make a bunch of changes in this file to make this work right and this is where the and let me actually undo this thing here just keep it there this is where the whole story starts breaking up a little bit because you have to make all these changes to accommodate the the progress of your application as you start introducing more directories things are going to change and this Docker file can easily get out of sync with the structure of your application right this has happened many times to me as we start making changes in there and then it happens to be that when we go into the pipeline the docker image is completely broken right because every didn't realize that something had to change here so this is where the new way of building Docker images can actually help so let me show you how that works let me actually just close all of this what I want to do is just bring up my uh my helicopter API CS block file first so let's go into this file here and in order to use this new way to build Docker images the first thing that you have to do is to add a brand new attack over here a brand new element into this property group uh which is is called enable SDK container support right so it's this one here and in this tag I don't mind this this one here is harmless and so um you want to say just here true okay so just by doing this and as you can see there's a prompt here that says turning your solar refinances this is going to bring in a few other dependencies from the.net SDK that is going to enable the ability to build Docker images directly by using the standard build process of off.net so just by adding this one line look at this this is what we can do now so I'll do here I go into my terminal over here and I'm going to clean this which has to make it bigger uh what we can do now is just say dot net publish and then you have to specify here what's going to be your uh your operating system so for for which operating system you're going to publish or create this documents remember that we selected that in the Wizard when we create a Docker file you have to do the same thing here so in this case the the OS that you want to use is a Linux and by the way Linux is the only one supported other than that I'm recording this video I think so there should be more options later on but for now let's stick with Linux and then of course you want to go into the release version of the application because this is for production and then lastly you want to specify what is known as the Polish profile so publish profile and then for this one everybody want to use here is default container okay so that is the kind of the minimum line that you need to to write in order to create a Docker container Docker image out of your project so just by doing that let me hit enter here what we're going to see is that now uh the.net sck produces an image right away uh using your project and as you can see right here it's selected uh the versions version seven zero of the asp.net image right the dot and SV net image and it created an image named hello Docker API and it did rename dot API by Dash API because it doesn't support the dot for some reason and use attack one zero zero and then it produces in the end this this image here hello is API colon a100 all right and so I didn't have to write any Docker file at all for any of this to happen and in fact let me to prove that let me just delete this Docker file here just get rid of that thing it is gone and I'm going to do this once again and of course it's going to be a bit faster because layers are a cache but it works just fine and if I Collapse this and I do now Docker images you're going to see that now we do have our brand new image available right here okay this one here and so yeah I mean by default it is that easy to register image using serial Docker file right it's not needed at all now one thing to keep in mind is that you do need to have Docker desktop installed and running in your box to make this work so it's not like you don't need Docker at all so you don't need to have Docker desktop installed so make sure you have that in there but other than that you don't need a Docker file anymore for for this and so we could also just verify that this this brand new created Docker image actually works and so let's go back into our Docker run syntax here so let's see if this is the same so it looks mostly the same uh but there's going to be one change here which is the fact that by default uh the port that's going to be used for your Docker image is now is now going to be Port 80 which is the default Port that's included in the aspin at 7 a Docker image right so that's why I just changed this into 80 as you can see Port 80. uh there are ways to change that too but by default you're going to get that still we're going to go from the outside for the whole sport is going to be 5073 then mapped into Port 80 inside the local image and then the actual name of the image is no longer hello Docker classic but it's going to be hello Docker API which is inherited from the name of the project and then version one zero zero and so if I just hit enter as you can see we are running inside the docker containers just like before and if we go ahead and open our hello Docker HTTP file over here and we send a request you're going to see that it just works just like at any standard docking container things are working just like before right and in fact and you can see even the the metric is being tracked right there okay and there was no need to be very picky about where our projects are located how are the structure of the directory that does not need it at all as long as everything is is laid out and connected properly in the MS build way right with the Cs product files uh things should work as expected much more simpler than before okay now I'll stop that I'll close this and then well there were a few assumptions about this right so let me clean this again and let's do Docker images once again so how did it decide to create an image called hello Docker Dash API and with this tag right how do you decide on this on these things right so the what it is doing is actually making a few a few Decisions by convention right since it notices that this is an infinite core project because of the project SDK that we're using here and it is using version 7-0 because of that it is using the docker image for HP Net 7 right this just by convention is taking that but if you wanted to override that by and you say well I don't want to use that that as my base image you want to do something else you can always just come here and just say here container base image okay just like that and here you could type any other image that makes sense for your.net application and so here you could type something like MCR that Microsoft that com and then.net and then let's say you want to go for the asp.net 7-0 Alpine image right so Dash Alpine if it makes sense then that's how you would declare that a brand new base image if you wanted to uh I don't see I need for this and only for this demo so I'll just stick like that and then the other thing is that of course it it did generate this hello Docker Dash API name for the image but you're going to say well I want to use a different name for my image that doesn't make too much sense for me so what you can do is the following I mean you can either add another element over there or will it be more common I think is is this so Docker publish right so same syntax as before but we're going to add one more thing here which is going to be Dash B and then we're going to say container image name equals and then whatever name makes sense for you so let's say this is going to be hello docker Dash modern right because the other one was Classic this is going to be the modern version and so yeah let's do that and let's hit enter and we are going to see is that just by doing that it will go ahead and generate our brand new hello Docker modern uh Docker image right and if we do Docker images once again we're going to see that we have that available right here okay and so that's how you can overwrite in the name of the image and then well next question is going to be well what do we do about attack right I don't want to reproduce him attack one zero zero all the time right and so there's a couple of ways to address this right so by default what is doing is just taking the the version of your assembly so by by default any assembly is going to take version one zero zero that's not the default but you can override that a couple of ways uh first way is going to be by overwriting the actual version directly in your in your profile you can just say here I could be version variation and then let's close this let's say this is going to be version one zero uh let's say 99 okay and so just by doing that if we go ahead and run this command again let me actually clean this let's round the.net polish command again you're going to see that now it is going to produce version uh one zero nine nine right uh but I wouldn't I don't think that's going to be very common because usually the version is going to be somehow connected to your build process right so it's going to change depending on the new versions of the application that you're going to be producing not necessarily modifying the assembly version but because that can cause trouble it's going to come usually from uh some sort of a variable or environment variable in your build process or in your CI pipeline so I wouldn't do it this way the way that you can do this let me clean this is by using another argument in your command line so if you go back into our command line over here uh what we're going to do is just add one more thing which is going to be Dash B and then we're going to say container image tag equals and this is going to be version one zero one and just by doing that if I hit enter you're going to see that we indeed get the version one zero one of our Docker image okay if we can clean this and we say Docker images and you're going to see that we have our brand new version right here okay now from here you may want to start simplifying a a couple of things and one of the things that you can simplify is this line here it's just a bit more tour balls and you got to realize that some of these things you can start adding directly to the file so for instance this polish profile default container instead of having to type that every time what you can do is just come into your product file and you can just say here polish profile okay so just like that bullish profile and then here you want to type what you're putting right now into your command line is just going to be default container I'll copy that paste it here and by doing that let me clean this you can simplify this line by removing this parameter here right so now you don't have to do that just like that hit enter and that's going to have pretty much the same result as before okay so that's great and then comes the question of okay so if I can build and run my Docker image locally how do I or what kind of support is is built in for publishing this image into an actual container registry right so as you know you're going to take this image either into a public place like Docker Hub or into your private container registry like a for instance the Azure container registry right so luckily there there is built-in support for that already and let me show you how that works so let me first show you very briefly my Azure portal over here where I have already find this container registry held docker01 and if we go in back into repositories down here you're going to see that right now I have nothing so this is completely empty right so how can we take our image and polish it right here so let's get back to vs code over here and really all you have to do is just introduce a brand new tag here uh that is called container registry okay so container registry and then this is going to need to have the name of your registry right and so if you go back into the Azure portal briefly here we go into overview you're going to see that here's our login server right here so Hitler one that azurecr.io so I'm just going to copy that and I'm going to paste that over here okay so this is going to enable uh the docker publish command to be able to not just polish the image into your box but just push it directly into the Container registry now there's one more thing that you have to of course do here and it is the authentication into the races so that's something that the the docker the.net publish command cannot do for you you do need to authenticate first to the registry and it will also depend on what kind of register you're using behind the scenes but in this case what we want to do is let me expand this a bit more and perhaps yeah just have it like that what you want to do is uh well this is azure so first thing that I have to do is do AC AC login and of course for this what you want to have is the Azure CLI installed in your box so you have Azure CLI so I'm going to log in as my account right there there we are okay so we are logged in so login completed and now that I did that uh next thing that I have to do is to log in I mean that locked me into my subscription now I have to login into the registry itself so for that I'm going to do AC ACR login and then it has to provide the name of the container registry so the name is hello docker01 so I'm just going to copy that here and then we want to there are a few ways to authenticate against the registry but the only supported way right now at the time that I'm recording this is a the one that uses the username and password right and so for that let's go back into our registry over here and if we go into access keys I have already enabled you see this option here admin user this option right here by default it is disabled so you just have to go ahead and enable it and by doing that you do get a both a username and a set of passwords that you can use to authenticate to your registry and so let's use that so let's copy the username first so username we'll say you username and then Dash B for password back into the portal we're just going to go ahead and copy and copy the first password Here paste it here and then hit enter and that should go ahead and log me into the registry and as you can see login succeeded so we are pretty much ready to go ahead and publish into ACR so let's go ahead and clean this and let's run the same command that we run before right so Docker it doesn't publish with the Linux OS release version uh and version one zero one um yeah let's go ahead and hit enter and we should see now is that it's not just builds the image in my box using the the is using the.net tooling but it's also uploading now all of the layers of my Docker image into the remote Azure container registry and this may take a while depending on the size of your image of course and I might speed up the video a little bit over here but uh but yeah this is going to take all of your the layers of your thinner image until it is it is completely uploaded into the Container registry all right so the image has completed a uploading so it should be available now in the registry so let's just confirm that very quickly by going back to the portal here we are back in the portal if we go into repositories now but you can see that here is our hell Docker that modern repository that corresponds to the docker image if we click on that we're going to see that we do have version 101 of our image polish right there okay so it was that easy to go ahead and publish the image into the remote registry after doing the required Authentication and then finally one more thing that we can do here is just to verify that we can actually run I mean pull down and run the docker image our container based on this image that is living now in the remote repository right so how to do that well let me just go back into vs code over here and we're going to do is to first let's go ahead and actually just get rid of every single image in my box just to simulate that this is a brand new machine right and we're not using any cachet layers and to do that I'm going to do the following so let me just clean this and I'm going to actually cheat a little bit here by copying this Command right there this is a command that is able to just delete every single image in your box so I'm going to use around that and yeah that get rid of everything that is in my box and so as you will be able to see if I do Docker images now uh there's nothing in my box right so it's all empty and let's also make sure that there's nothing really being cached here so I'm going to just do Docker system Rune all right so that's going to get rid of every single layer that might be cached in my box and it reclaimed a little bit of space so there's really nothing nothing Docker related in my box at this point right so now we can go ahead and run that Docker image from the container registry so let's go ahead and use that command that we use before so let's see Docker run yeah so this is the the command I've used before but this time we have to add the name of the login server this one over here we'll add the login server is a prefix to the to the actual a Docker image and then remember that the image is not named API but it's named modern so Dash modern and the version that we use is version one zero one right so now we're going to try to pull down and run the image directly from that remote container register so let's see if that works hit enter and as you can see now we're downloading all of the layers for the for this image from the container registry directly so this could be either my box or any other box anywhere in the world right that has access to Internet and that is able to of course to authenticate to Azure first before it being able to download the image as I'm doing right now and as you can see it is up and running right and with same parameters that we used before and if we go into hello Docker at HTTP we should be able to go ahead and hit send request and just as before we are able to get our list of weather forecasts just fine and yeah of course the metric is also being counted a down here as you can see so yeah so that's really what I wanted to show you today I think this is this is great and if you want to learn a little bit more about this new capability of.net uh check out this page over here over here github.com SDK container builds is one right here uh this is the page where this kind of a project is being developed right and so this is going to give you all the information about a how to use this new capability you can go into the documentation right here and this is going to give you a bunch of getting started and ways to customize further your the your container with a point of other capabilities that that you can use with this I hope it was useful and if you'd like to know more about using Docker to deploy your notifications to the cloud please check out my site for complete courses where I cover that and many other topics essential for professional.net developers and don't forget to subscribe to the channel so that you're the first to know whenever I publish new videos thanks for watching and I'll see you next time

Channel: Julio Casal

Views: 7,964

Keywords:

Id: PtGTU7thBuY

Length: 39min 16sec (2356 seconds)

Published: Tue Feb 21 2023