.NETCore Docker implements containerization and private image repository management

1. Introduction to Docker

Docker is developed in Go language based on some features of Linux operating system. It provides operating system-level abstraction and is a container management technology that isolates the application's dependence on the infrastructure (operating system, etc.). Compared with virtual machines, Docker shares the hardware resources of the host machine and uses containers to provide an independent operating environment to run applications. The virtual machine is based on the Supervisor (virtual machine hypervisor) using virtualization technology to provide isolated virtual machines and provide a running environment on the virtual machine's operating system! While both provide great resource isolation, it’s clear that Docker has lower virtualization overhead!

Docker involves three core concepts: Register, Image, and Container.

1. Registry: warehouse. Used to store Docker images. For example, Docker's official Docker Hub is a public warehouse where we can download the images we need.

2. Image: image. Developers create an application or service and package it and its dependencies into a container image. An image is a static representation of an application's configuration and its dependencies.

3. Container: container. Container is a running instance of an image. It is an isolated, resource-controlled, portable runtime environment that contains an operating system, programs to be run, dependencies of running programs, environment variables, etc.

The interaction between the three is:

When we execute the Docker pull or Docker run command, if the required image is not available locally, an image will be downloaded (pull) from the repository (usually DockerHub). Docker executes the run method to obtain a container, and the user performs various operations in the container. Docker executes the commit method to convert a container into an image. Docker uses commands such as login and push to push local images to the warehouse. The image can be used on other machines or servers to generate containers and run corresponding applications.

2. Docker Installation

1. Use yum source to install. Since the official source is slow to access in China, add Alibaba's source here

 > wget -P /etc/yum.repos.d/ http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
 > yum install -y docker-ce

2. Start Docker

 //Start Docker CE
 > systemctl start docker
 > systemctl enable docker
 //Check Docker status> systemctl status docker
 // Check the docker version> docker -v

3. Test whether Docker is installed correctly and execute the command:

> docker run hello-world

a. When executing docker run hello-world , docker will first look for the hello-world image locally. If it is not available locally, it will pull the image from the default image repository Docker Hub. After the image is pulled locally, the image is instantiated to obtain a container, and Hello from Docker! is output.

b. Docker Engine provides the core technologies of Docker: images and containers. In the last step of the installation tutorial, you ran the Engine command docker run hello-world . This command enables Engine to complete the core tasks of Docker. The command consists of three parts.

c. A container is a simplified version of the Linux operating system. An image is the software loaded into this container. When you run this command, Engine will do the following:

1. Check whether the hello-world software image exists

2. Download the image from Docker Hub (learn more about Docker Hub later)

3. Load this image into the container and run it

3. Running the .Netcore project in Docker

1. Pull the microsoft/dotnet image and wait for a few minutes to complete the installation. Execute docker images to see that the local computer already contains the microsoft/dotnet image.

> docker pull microsoft/dotnet

2. Run the microsoft/dotnet image. Use docker run <image> to start the image and specify the -it parameter to start it in interactive mode (enter the container). Execute the following commands in sequence:

 > docker run -it microsoft/dotnet //Start a dotnet image> dotnet new mvc -n mvctest //Create a .NET Core MVC project named mvctest> cd mvctest //Enter the mvctest folder> dotnet run //Start the .NET Core MVC project

The running results are shown in the figure below:

Press Ctrl+C on the keyboard to close the application, and enter exit to exit the current container

The above simple steps complete the creation and operation of a .NET Core MVC project. At this time, you may be curious. The .NET Core SDK is not installed on the Linux host. How is the MVC project created? This is where Docker’s magic happens. The dotnet image we pulled from the image repository contains all the dependencies and runtime environment needed to create, build, and run .NET Core projects.

After exiting the container, we execute find -name mvctest (to search for the mvctest file), and we find that it is not found. This means that the .NET Core MVC project we just created is created inside the container and is completely isolated from the host machine. At this point, you may be thinking that it is too inconvenient to install the source code in the container every time. Can we let the container run the source code project of our host machine? Well, that's a good question. Of course it is possible, let’s answer this question below.

4. Create a .NET Core project on the host

In order to create a .NET Core project on the host, we need to install the .NET Core SDK on the Linux host.

1. Install .NET Core SDK on the host

Add the yum source: sudo rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm

Start the installation: yum install -y dotnet-sdk-2.1

Check the installed version. The following figure shows that the installation is correct.

2. Create a .NET Core project

 > mkdir data
 > cd data
 > dotnet new mvc -n mvctest //Create a .NET Core MVC project named mvctest> cd mvctest //Enter the mvctest folder> dotnet run //Start the .NET Core MVC project

Note: Add the code .UseUrls("http://*:5000") to the Program.cs file and access it in the browser as shown below:

The next step is to share the source code project in this directory into the container by mounting it.

3. Mount the host project into the container

When starting a Docker image, Docker allows us to mount the host's files to a specified directory in the container by using the -v parameter. In other words, it is equivalent to sharing the specified file on the host for the container to access

// The `\` in the command combined with the `Enter` key forms a line break, allowing us to enter a long command in a new line.
 > docker run -it \
 > -v /data/mvctest/:/app \
 > microsoft/dotnet:latest

The above command mounts the files in the /data/mvctest/ folder to the \app directory of the container.

From the above execution results, we can see that the app directory inside the container contains the source code project on the host machine.

As mentioned above, it is in a shared form, rather than the container having a copy of the host directory, which means that changes to the directory on the host will be reflected in the container immediately. But on the other hand, changes to the shared directory in the container will not be reflected on the host machine, otherwise the isolation characteristics of the container will be broken.

Through such a simple scenario, are you smart enough to think of how this scenario can be applied in our daily coding? Yes, we can use it for continuous build (CI). The basic idea is to clone the source code to the host machine through git, and then mount the source code directory into the container for construction.

4. With the help of Dockerfile

In the next article, we will upgrade this operation, without the dependency of Dockerfile, and complete it with one command.

Dockerfile is used to define the series of operations you will perform in the container. Let's create our first Dockerfile

 > cd /data/mvctest/ //Make sure you enter the MVC project directory we created> touch Dockerfile //Use the touch command to create a Dockerfile
 > vi Dockerfile //Use vi command to edit Dockerfile

After entering the VI editing interface, copy the following code and use the shift + Ins command to paste it. Then press ESE to exit the editing mode, press shift + :, and enter wq to save and exit the editing interface.

FROM microsoft/dotnet:latest
 WORKDIR /app
 COPY ./app
 RUN dotnet restore
 EXPOSE 5000
 ENV ASPNETCORE_URLS http://*:5000
 ENTRYPOINT ["dotnet","run"]

I will explain the above commands one by one:

Use FROM to specify the image used by the container

Use WORKDIR to specify the working directory

Use the COPY command to copy the current directory (where . represents the current directory) to the /app directory in the container.

Use the RUN command to specify the command to be executed in the container

Use EXPOSE to specify the port number exposed by the container

Use ENV to specify environment parameters, which is used to tell the .NETCore project to listen on port 5000 on all network interfaces.

Use ENTRYPOINT to specify the entry point of the container

Now that the Dockerfile is ready, we can package our current project into an image for distribution and deployment.

Use the docker build -t <name> <path> command to package the image:

> docker build -t mvctest.web .

The above command tells Docker to package the current directory into a mirror and name it hellodocker.web . After the command is executed, enter docker images to see our newly packaged image

After the image is created, we can run it directly:

> docker run -d -p 80:5000 mvctest.web

The above instruction runs our newly packaged image and maps the container's port 5000 to the host's port 80 through the -p parameter. The -d parameter tells Docker to run the image as a background task. Because port 80 is the default web port, we can access the MVC website running in our container by directly accessing the IP through the browser

So far, we have perfectly completed the container deployment of the .NET Core project with the help of Docker. Later, we will deploy the image on other machines.

5. Push the image to the warehouse

Please register an account on Docker Hub, and then put the locally packaged image in the repository under your account.

1. After registration, execute the command

> docker login

2. Execute the command again

> docker push

The push failed, indicating that our image naming does not conform to the specification. It turns out that before pushing, the image must be named in the <user>/<repo> format. How to rename it? We rename it by tagging

The above information indicates that the push was successful. Check your own warehouse, as shown below:

Finally, we change a machine and execute the following command directly to complete the multiple deployment.

> docker run -p 8081:5000 79522860/mvcdemo.web

The above image repository is ready. Isn’t it very convenient? If combined with the business, you will find that more images are needed. Do you have to start the containers one by one for distributed deployment of containers? No, we can also deploy images and containers with one click through configuration files, which we will talk about in the next article.

6. Common Docker commands

1. Container-related operations

 > docker ps //View the currently running container> docker ps -a //View the status of all containers> docker start/stop id/name //Start/stop a container> docker attach id //Enter a container (the container will also stop running after exiting using exit)
 > docker rm id/name //Delete a container. If it is running, stop it first> docker rm $(docker ps -a -q) //Delete a stopped container> docker logs -f hello-world //View the log records of the specified container

> docker run -it --name hello_001 hello-world //創建一個容器，并指定標簽

-i: allows us to interact with the container (STDIN)

-t: specifies a pseudo terminal or terminal in the new container

--name: Give the container a name, which can be omitted. If omitted, Docker will generate a random name.

2. Image related operations

 > docker images //View local images> docker rmi id/name //Delete an image. If no tag is specified, the latest tag is deleted by default> docker rmi $(docker images -q) //Delete all images, be careful> docker rmi $(docker images -f "dangling=true" -q) //Delete all unnamed images (may be intermediate images generated during the build process)
 > docker start/stop id/name //Start/stop a container> docker attach id //Enter a container (the container will also stop running after exiting using exit)

Mirror by ID tag. The following is a tag of a local image with ID 0e5574283393 to the "fedora" repository, with tag name version1.0

> docker tag 0e5574283393 fedora/httpd:version1.0

Mirror by name tag, use the name "httpd" tag to mirror locally to the repository "fedora", and its tag name is version1.0

> docker tag httpd fedora/httpd:version1.0

Note that since the tag name of the referenced httpd is not specified, the default reference is httpd:latest

Tag an image by name and tag name. Tag a local image named httpd and tag name test. Its repository is fedora and the tag name is version1.0.test.

> docker tag httpd:test fedora/httpd:version1.0.test

Tag an image to a private repository. Push an image to a private registry instead of the public Docker registry. You must specify a registry hostname and port to tag the image.

> docker tag 0e5574283393 myregistryhost:5000/fedora/httpd:version1.

3. Uninstall Docker CE

a. Uninstall the Docker package

> yum remove docker-ce

b. Images, containers, volumes, or custom configuration files on the host are not automatically deleted. Delete all mages, containers, volumes commands

> rm -rf /var/lib/docker

6. Additional knowledge popularization

1. Docker official image library address

https://hub.docker.com/r/microsoft/dotnet/

2. Differences between microsoft/dotnet image versions

a. microsoft/dotnet:<version>-sdk (microsoft/dotnet:2.1-sdk)

This image includes the .NET Core SDK with .NET Core and the command-line tools (CLI). This image will be mapped to the development scenario. You can use this image for local development, debugging, and unit testing. This image can also be used to build scenarios. Using microsoft/dotnet:sdk always provides the latest version.

b. microsoft/dotnet:<version>-runtime (microsoft/dotnet:2.1-runtime)

This image contains .NET Core (runtime and libraries) and is optimized for running .NET Core apps in production environments.

c. microsoft/dotnet:<version>-runtime-deps

The runtime-deps image includes the operating system with all the native dependencies required by .NET Core. This image is intended for standalone applications.

3. Image acceleration

Due to domestic network problems, subsequent pulling of Docker images is very slow. We can configure an accelerator to solve this problem. I use the NetEase mirror address: http://hub-mirror.c.163.com.

New versions of Docker use /etc/docker/daemon.json（Linux） or %programdata%\docker\config\daemon.json (Windows) to configure Daemon.

Please add this to the configuration file (if there is no such file, please create one first):

{
"registry-mirrors": ["http://hub-mirror.c.163.com"]
}

#Refresh the configuration file and restart docker

systemctl daemon-reload

systemctl restart docker

**********If you use aliyun, you need to log in to your Alibaba Cloud account to get your own mirror address************

Summarize

The above is the .NETCore Docker containerization and private image repository management introduced by the editor. I hope it will be helpful to everyone. If you have any questions, please leave me a message and the editor will reply to you in time. I would also like to thank everyone for their support of the 123WORDPRESS.COM website!
If you find this article helpful, please feel free to reprint it and please indicate the source. Thank you!