Process analysis of deploying ASP.NET Core applications on Linux system Docker

1. System environment

1. Tencent Cloud Lightweight Application Server CentOS7.6

2. Operation process and problems encountered along the way

1. SSH remote Linux

ssh <username>@<IP address or domain name>

If you encounter the following problem:

The reason for this problem: known_hosts is a file that records the public key of the remote host. The system was reinstalled before, and the saved public key is still the system public key of the system that was not reinstalled. When connecting to ssh, the public key will be verified first. If the public key is incorrect, an error will be reported. Solution: Use the shh-keygen command ssh-keygen -R IP . After execution, the following figure appears:

Then use ssh to remotely connect to Linux:

2. Update the system

sudo yum update

3. Install Git

sudo yum -y install git

4. Install Nginx, enable and start the service:

sudo yum install nginx
sudo systemctl enable nginx
sudo systemctl start nginx

5. Install Dotnet SDK

You only need to do this once per computer.

sudo rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm
sudo yum install dotnet-sdk-5.0

6. Install Docker environment

1) Install the Docker source:

First, we can execute the uninstall command. If you have installed it before or it comes with the system, you need to uninstall it cleanly:

sudo yum remove docker-ce

Then we can install the specified source. There are official versions and Alibaba Cloud versions. I will try to use the Alibaba Cloud version here. I heard it will be faster.
Step 1: Install some necessary system tools

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

Step 2: Add software source information

sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

Step 3: Update and install Docker-CE

sudo yum makecache fast (optional)
sudo yum -y install docker-ce

Step 4: Start the Docker service

sudo service docker start

Set up Docker startup

systemctl enable docker

Start Docker

systemctl start docker

View Version

docker --version

Docker Common Commands

View all docker images
Delete an image with imageid

docker rmi [imageid]

Delete all images

sudo docker rmi $(docker images -q)

View the running status of all containers

docker ps -a

Delete a container (instance) with containerid

docker rm [containerid]

Delete all containers

docker rm $(sudo docker ps -a -q)

2) Test Hello World

Check whether Docker can run normally (run the hello-world image. If the local machine does not have the hello-world image, the system will automatically pull the hello-world image)

docker run hello-world

At this time, we can check:
What images are currently available on the server?

docker images

How to check which containers are there?

docker ps -a

This is the container with output content we just saw: the container ID is eb180038a3ce, the image is hello-world, and the status is exited.

7. Publish your own image

1) Add Docker support:

Customize the interface to be exposed by the project

Right-click on the Api layer to add Docker support and select Linux

Change the Dockerfile

FROM: means which is our project source mirror;
WORKDIR: The working directory of the image;
COPY: copy files (copy files in the directory where Dockerfile is located to the working directory in the image)
EXPOSE: The port that the container wants to open (we use port 8081 of the project)
ENTRYPOINT: The command to be executed after the container is started (the dotnet Docker.Core.Api.dll command will be executed here)

2 script files: Docker.Core.Publish.Linux.sh and Docker.Core.Publish.Docker.sh

Dockerfile: Then right click, always properties, always copy to output (bin) directory Next, publish the project to GitHub or Gitee: I publish it to GitHub and then go to Gitee to force synchronization of the project. It is faster to clone the project from China

2) Release

We use Git to pull the code on the server, and then execute the release command. I use a batch file to generate it directly with one click (mainly to prevent missing files):

Execute the release command:

You can see the generated publishing folder PublishFiles.
The next step is to compile the Docker image.

3) Create an image

Go to our publishing folder PublishFiles folder and test whether this file is normal:

dotnet Docker.Core.Api.dll

After all is OK, start building, still in the current folder (remember that point):

docker build -t lenceas/apkimg .

Where lenceas/apkimg is our mirror name.
Because our Dockerfile has five steps, there are exactly five steps here.
Then check the image on the machine:

There are two more images here, one is our image ID 48252cd5c2d0, the size of the project file is 209M, and the other is the source image of our Dockerfile.

4) Push the image to the Docker hub repository

Step 1: Register an account on Docker hub Step 2: Create a repository

Step 3: Server image push Log in to your account first (if you have logged in before, you can log out and log in again)

Push:

docker push lenceas/apkimg:latest

examine:
We log in to the management backend to view the results

You can see that it has been pushed successfully. In this way, we can use my image anywhere.
Now that we have an image, we can create a container, because containers can only run.

8. Generate and run the container

1) Generate a container

With the image, let's generate a container:

docker run -it -p 8081:8081 lenceas/apkimg

You will see the output. If there is no error, congratulations. Exit the current process and check which containers are there:

At this time, you can see that there is an additional container ID e45b93658007, and the image is the lenceas/apkimg container, but our project container is in the exit state and needs to be opened:

docker start e45b93658007

The status is already running, so how to test whether the interface is normal? You can use the curl command:

curl http://localhost:8081/WeatherForecast

If you have reached here, congratulations, Docker deployment of NetCore has basically been completed. The last step is nginx proxy. Because our Docker has already guarded this process, we do not need other daemon processes.

9. Nginx proxy service

Modify the nginx.conf file in two ways:
1. vim command to edit files: vim xxx
Insert start editing: i
Save and exit: :wq!
2. Download via FTP to local computer and modify the configuration. I won’t write the specific configuration here, you can search it online.

The next step is to restart the Nginx service. First, you can detect syntax errors:

nginx -t

nginx -s reload

The above is the details of Linux Docker deployment of ASP.NET Core applications. For more information about Docker deployment of ASP.NET Core applications, please pay attention to other related articles on 123WORDPRESS.COM!