Skip main navigation

New offer! Get 30% off your first 2 months of Unlimited Monthly. Start your subscription for just £35.99 £24.99. New subscribers only T&Cs apply

Find out more

How to Build, Push and Run Docker Images Using VSTS

Hi, this is Colin from Northwest Cadence. In this video, I’m going to show you how we can build and publish a .NET core application to a Docker container in our build that we can then run in a release. Here, I’ve opened up the build definition for my Docker test app. I have a couple of commands. The first one runs .net.restore. It does this in the context of the test application where my project lives. I then do the same thing. And this time, I do a .net.publish. And here, I’m specifying framework and runtime as well as the output directory to the published command. These are variables that I’ve set up on the build.
Here, you can see the runtime and framework variables that I’m using in order to run this application within a Docker container. You’ll see that we’re outputting the published application to the ArtifactsStaging Directory/Site.App. This folder is important for when we build the Docker image. And then I’m using a Docker task which I’ve installed from the Visual Studio marketplace in order to build the Docker image. I’ve had to create two service endpoints in order for this to work. One is to a Docker host which I’ve called cd-dockerhost. And one is to Docker registry. In this case, it’s my Docker registry in Docker Hub. You can read about how to set up these connections using this URL.
You’ll see under the Action parameter that there are several actions that this task can perform. In this case, we’re going to build an image. We specify the Docker file. In this case, I’m pointing to the released Docker file. I’m giving it an image name within my repository. And I’m using Build.BuildNumber as part of the tag. So each time I create a build, I’ll get a new image where the tag refers to the build number. Finally, I’m supplying the context. And this is the folder that contains the app. So if I go back to .net.publish, you’ll see we’re putting the application into an app folder. This app folder has been copied using the Copy command in the Docker file.
This will then build a Docker image for me. In the next step, I’m going to publish that to my Docker registry. So I’m using another Docker task. And this time, the action is Push an Image. I’m going to use the same image name so that it’s pushed to my repository with the same tag that I used when creating my image in the Docker build task. Finally, I’m using a Publish artefact to publish the ArtifactStagingDirectory directory so that I have my compiled code– in this case, the .NET core published application– outside of the Docker container. Of course, this is totally optional.
Here’s a previous build that ran successfully. You can see that we’ve successfully run .net.restore and .publish, and then built and pushed the image. If I go ahead and look at my repository in Docker Hub, you can see that I have tags for TestApp-1.0.18 as well as 1.0.19. The 1.0.19 tag was the result of the 1.0.19 build. Now that we have a build that’s pushed an image to a registry, let’s see how we can run that during a release.
In this release, I only have a single task. Again, it’s the Docker task from the marketplace. And this time, the action is Run an Image. I’m using the same endpoints to the Docker host and the Docker registry as we saw in the build definition. I’m also using the same image name. And I’m using, again, BuildABuildNumber to specify which build of this image I want to be running. I’ve linked that in the Artefact section where the DockerTestApp build is the Artefact for this release.
We can give a name to our container. We can specify any port mappings as well as any other environment variables. We can also supply additional commands for the container if we need to. Let’s go and see one of the previous releases. We can see release two completed successfully.
If we check the logs, we can see that the Run an Image task completed successfully. So let’s go and navigate to port 5000 on our Docker host. Here, we can see the template project that we’ve been working with running inside a container in our Docker host. In this video, I showed you an overview of how to build, push, and run Docker images using VSTS build and release management.
This article is from the free online

Microsoft Future Ready: Fundamentals of DevOps and Azure Pipeline

Created by
FutureLearn - Learning For Life

Reach your personal and professional goals

Unlock access to hundreds of expert online courses and degrees from top universities and educators to gain accredited qualifications and professional CV-building certificates.

Join over 18 million learners to launch, switch or build upon your career, all at your own pace, across a wide range of topic areas.

Start Learning now