DEV Community: StackUpDev

Getting Started with DockerFile for Asp.Net Core

StackUpDev — Wed, 09 Jun 2021 10:43:25 +0000

So over the past few days I have been working on a .Net Core API which was using SQL Server via the Entity Framework Core. Now since I am using M1 Mac the only way to achieve this was by running the SQL Server on docker.

The implementation was straight forward but running the entire app on docker was bit tricky and it took some time to figure it out. So once I was successful, I thought why not jot down my understanding of the docker file created by Visual Studio and how I completed this task

Pre-requisites

Visual Studio IDE or Visual Studio Code along with Asp.Net Core framework
Docker Desktop up and running on the system
Dot Net API Solution, the one I am using has a dependency on SQL Server (https://github.com/rajat-srivas/GallaSoft.RetailerOnboarding)

Requirement

We need to run the application entirely via docker
SQL Server container should be up and running before the .Net container as it is required for seeding the initial database using the Entity Framework migrations

Creating the Docker File

So I believe that you already have a project ready on which we are going to follow this step
We will use the default dockerfile generated via Visual Studio for our implementation
To add Docker Support: Right click on the Project >> Add >> Docker Support
This will create three files in the solution, Dockerfile, docker-compose.yml and dockerignore
We are going to focus on the first two files and understand it content

Dockerfile

FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
WORKDIR /src
COPY ["GallaSoft.RetailerOnboardingAPI/GallaSoft.RetailerOnboardingAPI.csproj", "GallaSoft.RetailerOnboardingAPI/"]
RUN dotnet restore "GallaSoft.RetailerOnboardingAPI/GallaSoft.RetailerOnboardingAPI.csproj"
COPY . .
WORKDIR "/src/GallaSoft.RetailerOnboardingAPI"
RUN dotnet build "GallaSoft.RetailerOnboardingAPI.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "GallaSoft.RetailerOnboardingAPI.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "GallaSoft.RetailerOnboardingAPI.dll"]

let's break down these 4 stages here and try to get some more detailed info about each and every one of them

FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

The FROM command is used to specify the base image which is the Asp.Net 5.0 runtime environment required to run dot net based applications and name it is as base here
We then use the WORKDIR command to change the working directory for subsequent instructions in the Dockerfile
We also expose the ports 80 and 443

FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
WORKDIR /src
COPY ["GallaSoft.RetailerOnboardingAPI/GallaSoft.RetailerOnboardingAPI.csproj", "GallaSoft.RetailerOnboardingAPI/"]
RUN dotnet restore "GallaSoft.RetailerOnboardingAPI/GallaSoft.RetailerOnboardingAPI.csproj"
COPY . .
WORKDIR "/src/GallaSoft.RetailerOnboardingAPI"
RUN dotnet build "GallaSoft.RetailerOnboardingAPI.csproj" -c Release -o /app/build

Now in this stage we are actually building our project and just before that we run the restore command to make sure all dependencies are resolved
We are also changing the base image and working directory of our container here
The base image is now the dotnet sdk named as build which is required to build and restore our project
Working directory is changed as we want to keep the size of eventual container as small as possible and we dont need the sdk as we will require only the published file in the image
COPY command is used to copy the content from source to destination. Here being from the project directory to the WORKDIR
Then we run the dotnet restore command on the project, copy everything to the WORKDIR
We then build the project in Release mode and specify the output directory

FROM build AS publish
RUN dotnet publish "GallaSoft.RetailerOnboardingAPI.csproj" -c Release -o /app/publish

Now we have the build files of our project and next step is to use the build base image to publish our project in the output directory specified

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "GallaSoft.RetailerOnboardingAPI.dll"]

In the final stage we again go back to the base image of dotnet runtime as we dont need the build sdk anymore
We only copy the entire content of the publish folder to our image
Finally, we just specify the ENTRYPOINT which will be used to run the app when the container is ran using this dockerfile

Now since we have gone through the Dockerfile which was created, we move on to the docker-compose.yml file which is actually used to build this project using the dockerfile

We will have to create this on our own and let's discuss how we have done this for our usecase

Docker Compose

If your project doesn't have any dependency that needs to be locally present, then the docker-compose file will only have instruction to create and run a container from the dockerfile.

But since here we need to have the SQL Server running before the dotnet project is ran, we specify and create this dependency

version: '1.4'

services:

  db:
   image: "mcr.microsoft.com/azure-sql-edge"
   container_name: sql-server-db
   ports:
      - 1433:1433
   environment:
      - SA_PASSWORD=MyPass@word
      - MSSQL_PID=Developer
      - ACCEPT_EULA='Y'


  gallasoft.retaileronboardingapi:
    image: ${DOCKER_REGISTRY-}gallasoft
    ports:
       - 49838:443
    build:
      context: .
      dockerfile: GallaSoft.RetailerOnboardingAPI/Dockerfile
    depends_on:
      - db

For our API to run, we need to two services to be running on the docker container, the db which refers to the SQL Server instance and the API project itself

Note: I am using the Azure SQL Edge version of SQL and not the SQL Server since at the time implementation this was the best way to run an instance of sql server on M1 powered MacBooks.

db Service

The properties mentioned here are similar to the one used while we run the container using the docker run command
We specify the image, container name, ports and the password which will be used to the access the server

api Service

This step is to use the Dockerfile and create and run image
The important thing here is the depends_on tag which specifies that this service depends on the db service and hence, it must be up and running for seeding data before we run it.

So, that is all the overhead which is required to containerise our dot net core apps.

Finally, we can now either run the docker compose command from command prompt/terminal or Run the project from Visual Studio directly.

Conclusion

We should have the API project running in the browser and the two docker containers running as well.

Thanks people if you reached till here. You guys are awesome. Keep learning, keep building 🚀🚀🚀🚀🚀🚀

Creating a custom SQL Server Docker Image on top of the Official Image

StackUpDev — Wed, 09 Jun 2021 06:48:48 +0000

Hello people, so today let's discuss how we can create our own custom SQL Server image on top of the official image.

This can be really useful in multiple scenarios like when we have a new team member joining our team. Instead of giving them a fresh instance of SQL Server we can have an image of the initial setup and they can just pull it and be ready to work on it

Pre-requisite

Docker Desktop up and running on the machine. Can be download from here https://docs.docker.com/v17.09/docker-for-windows/install/
Account on Docker Hub so that we can publish and then pull our custom Sql Server docker image
Running instance of a fresh SQL Server container from the official image available on docker hub mcr.microsoft.com/mssql/server:2017-latest.

docker run -e "ACCEPT_EULA=Y" "SA_PASSWORD=MYPASSWORD123" -p 1433:1433 --name MyContainerName -d mcr.microsoft.com/mssql/server:2017-latest

Setting up the SQL Server 🔥

Once we have the server up and running, login to the SQL Server using SQL Server Management studio with the IP address of the host
Username would be SU and password is MYPASSWORD123 as used in the command above to run the container
Next we can setup our server like the database, tables manually or using any backup file etc
Now we have our database in place and we want to create an image of this setup so as to when next time someone pulls the image they don't have to manually import the database anymore

Create Custom Docker Image

Firstly, stop the running container using the command

docker stop MyContainerName

Next we push our changes on to the container so that we can build an image of it

docker commit MyContainerName

Then copy the image of our specific container from the list using the command

Docker images

The newly created image does not have a repository and tag. Execute the following command to tag the image

docker tag <imageID> <docker-hub-username>/<docker-hub-repository-name>:<tag-name>

For example: docker tag a82e969d1395 rajatsrivas/ myownsql:sqlCustomImage

Now our image is built and we can create a container using the image

docker run -p 1433:1433 --name sqlCustomImage -d rajatsrivas/ myownsql

If you are logged into docker hub on local Docker Desktop this step will be skipped else login using the command prompt

docker login -username=rajatsrivas

Enter the password into the next line and finally push the image to the docker hub repository

docker push rajatsrivas/myownsql

Go to https://hub.docker.com/
We should have the image which we pushed to the docker hub

Pull and Run our Custom Image 🏃‍♂️

Pull the image on to any machine using the command

docker pull rajatsrivas/myownsql:latest

Run the container and access the server on the SSMS. The server should have the database which was imported and setup in the earlier steps

docker run -p 1433:1433 --name <container-name> -d rajatsrivas/myownsql:latest

Conclusion

So there it is we have implemented our custom image on top of an official docker image available.

This is quite a small step in onboarding but one can leverage similar implementations for setting up sandbox environments very quickly and efficiently.

Hope this was useful. Keep learning keep building

Implementing your first Build Pipeline for Asp.Net Core using TeamCity Cloud & Docker Hub

StackUpDev — Wed, 09 Jun 2021 06:07:33 +0000

Hey guys, so recently I had this requirement which required me to integrate a build process for .Net Core app using the Github, TeamCity Cloud server and Docker Hub.

So I researched about it and went on to implement it, and here's in brief what I did.

I used the out of box project created by Visual studio and manually added a docker file in it.
I then went on to create a free trial account on the TeamCity cloud server where I used this docker file to build, publish and then push the docker image to my Docker Hub repository
Finally I pulled the docker image on anther machine and there it was our weatherforecast api up and running 🚀 🚀.

Since I did could find a proper resource for implementing the same I thought why not give it a go myself. So here I am trying to explain the steps I followed.

Pre-requisite

Account on Team City Cloud Server https://www.jetbrains.com/teamcity/cloud/
Docker Hub account with a repository to publish the image of the asp.net core solution https://hub.docker.com
Docker Desktop Installed on local to pull and run the deployed image
Sample Dot Net core solution with a docker file. You can refer the one I am using here https://github.com/rajat-srivas/dotnetcore-teamcity-docker
I am also assuming you know about docker and are here to understand how to implement this integration

Project Setup On TeamCity Cloud Server

Login into your team city cloud server
Click on Project and then create project

Next we will be connecting our TeamCity server to the GitHub repository so as it can pull up the code every-time there is a new commit
Provide the repository URL (https://github.com/rajat-srivas/dotnetcore-teamcity-docker), and credentials to access the repository

Provide the project name and click on Proceed
Next we need to connect our Docker Hub repository to team city.
Go the Projects setting page and click on Connections.
Click on Add Connection and configure Docker Registry

Go back to the build page
Click on Add Build Feature and select Docker Support.
Click on Add Registry Connection and use the docker connection created

Implementing the Build Pipeline 🏗

Click on Build Steps to start creating the build pipeline
For the current solution we need four build steps:
Net Build => Build the .net solution
Net Publish => Publishes the .Net Solution in the specified output directory
Docker Image Build => Reads the specified docker file to create the docker image which contains the content of the folder where .net core solution was published
Docker Image Push => Pushes the image on Docker hub

Refer the above image to create the builds as mentioned
Lets now move on the configure the individual steps

.Net Build

Here we just need to set the Command as Build and provide the name of the solution from the repository

.Net Publish

Next we need to specify the folder where the files will be published. This needs to be same as the COPY command source in the docker file.

Docker Build

Here rajatsrivas/testdeploy is the repository name on Docker hub in which my image will be published

I'm using the build.counter flag to automatically version the docker image generated so as to keep track of it with the actual build which was triggered

Docker Push

Now here the only thing left to do in the build configuration is to push the image which was created to our Docker Hub repo

Trigger/Run Build Manually

Click on Run at the top right corner to trigger the build.
Once the build is success, the image should be published in the docker repository specified 😄🍻

Running the App using the Docker Hub Image

Finally lets try and run the application using the image on our docker repository

Pull the image from docker hub using the command. docker pull rajatsrivas/testdeploy:
Run the container using the command below Docker run -p 80:80 --name rajatsrivas/testdeploy:

Conclusion

That's it, we have successfully implemented our first build pipeline for a Asp.Net core project using Github, TeamCity and Docker Hub.

Hope you find these steps useful and you can use it to build upon your own more complex build pipelines. Keep learning keep building...