As we previously examined how we can create a containerized azure devops agent running on a windows machine, we will now go through the same procedure but with linux OS.
You can read the windows container azure devops agent article using the below link:
The first thing that you will need is a virtual machine that runs docker. When this requirement is fulfilled you can jump on the image building. In order to build your image you will need your Dockerfile and the instructions for the agent.
You can read the rest of the article on Medium using the link below:
On previous articles I have explained how you can install an azure devops agent on the operating system in order to create your self hosted agent pools for your projects.
But what if you need to create multiple agents inside a virtual machine? The best solution would be to use docker virtualization and separate those agents from each other. We will now examine how we can host our azure devops agents on containers.
The first thing that you will need is a virtual machine that runs docker. When this requirement is fulfilled you can jump on the image building. In order to build your image you will need your Dockerfile and the instructions for the agent.
You can read the rest of the article on Medium using the link below:
When you build your application with cloud native technologies you will build microservices on containers instead of monolithic applications. We will now examine how easy is to build a .NET application in a container and run this application on your local machine.
First we will need to create the visual studio solution. I will go through that with visual studio IDE and then I will use vs code. For my microservice I am using a ASP .NET Core web api with default code.
The target framework for the solution will be the latest .NET framework which is version 7. All other settings will be set to defaults.
When you run the app locally with IIsExpress you will be able to access the swagger interface through the port which you defined in the launchSettings.json.
This file can be located under Properties and there you can configure on which port the application will run. In the profiles section under https settings, you can find the default application URL and port. This will be needed in later steps.
Microsoft provides the below documentation in order to create a containerized application that runs on .NET
In order to create a microservice based on our vs solution we will need a dockerfile. This can be created automatically with vs code.
In vs code command dialog search for docker add and select docker compose files to workspace.
Then select asp net core.
and after that your operating system. The next step will be to select the exposed port, or otherwise under which port your application will run. There we should provide the port that we found under our launchSettings.json or the one that we configured manually. In my case I will select the default one for the solution which was 7057.
When a popup window appears on the screen you should select add Dockerfile and automatically the build files will be generated.
Dockerfile
Based on my setup I altered two things in the generated Dockerfile. The first thing will be to change configuration to Debug instead of Release. For production environments you will consider using the release build directive. The second thing will be to add an environmental variable ASPNETCORE_ENVIRONMENT inside the container with the value Development.
FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base WORKDIR /app EXPOSE 7057
FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build WORKDIR /src COPY ["AspNetWebApi.csproj", "./"] RUN dotnet restore "AspNetWebApi.csproj" COPY . . WORKDIR "/src/." RUN dotnet build "AspNetWebApi.csproj" -c Debug -o /app/build
FROM build AS publish RUN dotnet publish "AspNetWebApi.csproj" -c Debug -o /app/publish /p:UseAppHost=false
FROM base AS final WORKDIR /app COPY --from=publish /app/publish . ENTRYPOINT ["dotnet", "AspNetWebApi.dll"]
docker build command
after the build is completed and the image is created you can run a new container locally.
Keep in mind that in order to test your container you should create a port forward from the container to your host. I used the same port for the host so I added the -p 7057:7057
The logs of the container indicate a successful run of the application.
Our application now runs as a microservice container inside the host machine (my laptop).
We can verify the access to our application using the URL with the swagger.
Docker images consist of layers, a mechanism that will result in lower build time for your containers. A detailed article about how layers work on docker can be found in the below url.
Each layer is an image itself, just one without a human-assigned tag. They have auto-generated IDs though.
Each layer stores the changes compared to the image it’s based on.
An image can consist of a single layer (that’s often the case when the squash command was used).
Each instruction in a Dockerfile results in a layer. (Except for multi-stage builds, where usually only the layers in the final image are pushed, or when an image is squashed to a single layer).
Layers are used to avoid transferring redundant information and skip build steps which have not changed (according to the Docker cache).
But what if you want to combine all the layers of an image into one single piece? This is why squash has been created.
How –squash works
Once the build is complete, Docker creates a new image loading the diffs from each layer into a single new layer and references all the parent’s layers. In other words: when squashing, Docker will take all the filesystem layers produced by a build and collapse them into a single new layer.
Build image without squash
docker build . -t test
Build image with squash
docker build . -t test1 --squash
In order to use squash command you will need to have experimental features enabled.
Navigate in docker desktop settings and in Windows (which is what I currently use) you should go on Docker Engine tab and change the experimental value to true.
After that you can run your docker command using —squash
Privacy & Cookies: This site uses cookies. By continuing to use this website, you agree to their use.
To find out more, including how to control cookies, see here:
Cookie Policy
