Gogs+Jenkins+Docker automated deployment of .NetCore steps

Environmental Description

• Tencent Cloud lightweight server, configuration 1c 2g 6mb , system is ubuntu 20.14 , Docker and Jenkins are on this server,
• One Synology 218+, Gogs is on this server.

Docker Installation

Uninstall the old Docker

sudo apt-get remove docker docker-engine docker.io containerd runc

Update the apt package index and install packages to allow apt to use the repository over HTTPS

sudo apt-get update

sudo apt-get install \
  apt-transport-https \
  ca-certificates \
  curl \
  gnupg \
  lsb-release

Add Docker official GPG key

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Install Docker

sudo apt-get install docker-ce docker-ce-cli containerd.io

Verify that Docker was installed correctly by running hello-world. Output Hello from Docker! indicates successful installation

sudo docker run hello-world

For different system installation methods, please refer to the official Docker installation instructions

Gogs Installation

Gogs is a lightweight and easy-to-build self-service Git service developed in Go language. The main reason for choosing Gogs is that it is much lighter than Gitlab, which has an internal usage rate of several GB. Gogs will greatly reduce system overhead and only takes up 100mb of memory when running. My Gogs runs on Synology, the results are the same, both are hosted in Docker

Pull the Gogs image

sudo docker pull gogs/gogs

Create a Gogs file mount path

mkdir -p /var/gogs

When starting container 6022, it is https, and 6080 is http. You can use the docker ps command to check whether it is started successfully.

docker run -d --name=my_gogs -p 6022:22 -p 6080:3000 -v /var/gogs:/data gogs/gogs

After the container is started, perform the initial configuration of Gogs through http://xxxxxxxx:6080

The recommended database type is SQLite3, which comes with Linux. It is sufficient to support a team of about a dozen people. Domain name: fill in the domain name or IP address of the server where Gogs is located. The http port number is consistent with the internal port of the container. Fill in the domain name port or IP port of Gogs in the application URL. Click Install and register a new user to log in.

After Gogs is installed, create a new Demo repository for later use

Gogs Official Documentation

Hosting .NetCore services in Docker

Create a new WebApi project

Add a DockerFile file to the project and simply configure it

#Specify the dependency version FROM mcr.microsoft.com/dotnet/aspnet:5.0-buster-slim 
WORKDIR /app

COPY ./publish
WORKDIR /publish
# Set the Docker container to expose port EXPOSE 80
# Set time zone RUN /bin/cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
    && echo 'Asia/Shanghai' >/etc/timezone 
# Program entry ENTRYPOINT ["dotnet", "DemoWebApi.dll"]

Publish the API service. If there is no DockerFile file in the published file, you need to manually modify the project file. After the release is successful, copy the published file to the folder specified by the server.

 <ItemGroup>
        <None Update="Dockerfile">
            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
        </None>
    </ItemGroup>

Go to the root path of the release file just copied on the server and execute docker build -t {REPOSITORY}:{TAG} . The command generates a Docker image file through DockerFile. REPOSITORY is the name of the image and TAG is the tag. For example, docker build -t demo:v1 .

Use the docker images command to view all generated images

After the image is generated successfully, you can create and run a container through the image. Execute docker run --name demoapi -dp 5009:80/tcp demo:v1 command to create and run the container.
-d: Run the container in the background and return the container ID;
-p: specifies port mapping in the format of host port: container port. The container port is the port where your program is started. It is recommended to hard-code it in the project.
-- name: container name

After execution, you can use docker ps to view the status of all running containers. To view all containers, you can use the docker ps -a command

Use postman to test whether the deployment is successful

List some common docker commands

• docker restart {容器id} #Restart the container
• docker start {容器id} #Start the container
• docker attach {容器id} # This will cause the container to exit, and attach allows the user to see the standard output of the container
• docker attach {容器id} --sig-proxy=false # Adding parameters will not cause synchronous exit
• docker exec -it {容器id} /bin/bash # To enter the container, you need to use the exec command to execute commands in the container.
• docker logs {容器id} -f # Tracking log output -f Tracking log output
• docker rm -f {容器id} # delete the stopped container
• docker rmi {REPOSITORY:TAG} # delete the specified image
• docker image prune # Delete dangling images, that is, images that are not referenced by containers

At this point, the service has been hosted in Docker, but each release requires building a new image, stopping the old container, and creating a new one, which invisibly increases the workload. Jenkins can do this for us

Jenkins Installation

Jenkins depends on Java, so you need to install the Java SDK. Here, select Java 8.

sudo apt-get install openjdk-8-jdk

Installing the LTS version of Jenkins

wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -
sudo sh -c 'echo deb https://pkg.jenkins.io/debian-stable binary/ > \
    /etc/apt/sources.list.d/jenkins.list'
sudo apt-get update
sudo apt-get install jenkins

Check the running status systemctl status jenkins Normally, the output will be as follows

The default port of Jenkins is 8080. After successful installation, you can access it through http://xxxx:8080 . The first step is to unlock it. The administrator password will be output after successful installation. You can also use the command cat /var/lib/jenkins/secrets/initialAdminPassword

After entering the password, enter the initialization page and choose to install the recommended plug-in

The plugin installation progress may take some time.

After the completion, create an administrative account to log in, enter the system management, select plug-in management, search for gogs plug-in and install it.

After installation, you need to restart Jenkins. Visit the link http://xxxx:8080/restart and click Restart, or execute service jenkins restart to restart.

To facilitate script execution, you need to let Jenkins run as the root user. Edit the file vim /etc/sysconfig/jenkins or vim /etc/default/jenkins , uncomment JENKINS_USER , set the value to JENKINS_USER="root" and then modify the folder permissions.

chown -R root:root /var/lib/jenkins
chown -R root:root /var/cache/jenkins
chown -R root:root /var/log/jenkins

Jenkins common operations

• Start service jenkins start
• Restart service jenkins restart or visit http://xxxx:8080/restart
• Stop service jenkins stop or visit http://xxxx:8080/exit
• Reload the configuration file http://xxxx:8080/reload

Automation with Jenkins

Because you need to build the project on the server, you need to install the .NetCore environment. You can refer to the official Microsoft documentation to install it yourself.

Push the newly created project to the Gogs repository and click on the repository advanced settings

Select Web Hooks and add a new Gogs web hook

Configure the web hook. The push address is preceded by the Jenkins access link, and the job name can be defined by yourself. You can choose to trigger the hook only when pushing, or you can select the event yourself.

After adding, click Manage Web Hooks again, select the newly created hook, and click Test Push to verify whether it is normal. If the exception thrown is that the job is not defined, it means that the hook is normal. If it is other exceptions, you can check whether the push address is correct and whether the Gogs plugin on Jenkins is installed correctly.

Go back to the Jenkins page and create a new task. The task name is the same as the job name in Gogs. Select Build a Free-Style Software Project.

Add repository configuration. Repository URL is your repository address. Click to add your repository credential information. Finally, specify the branch for the operation.

Build and select execute shell script. The script can also be placed on the server and called here. For convenience, just write it here

# Check if the demo image exists or if docker images exist | grep demo &> /dev/null
if [ $? -ne 0 ]
then
   # No processing if it does not exist echo "not existed demo"
else
    # If the image exists, the container is assumed to be running by default echo "existed demo"
   	# Stop deleting containers and images docker stop demoapi
    docker rm -f demoapi
    docker rmi demo:v1
fi

# Rebuild and generate the image and run the container cd DemoWebApi/
# Publish to the specified path dotnet publish -c Release -o /publish
# Enter the path to generate the image and start the container cd /publish
docker build -t demo:v1 .
docker run --name demoapi -dp 5009:80/tcp demo:v1 

After saving, click Build Now to verify. If the build fails, you can view the detailed build process and error information in the console output.

Go back to the Gogs management web hook page and push again. If successful, Jenkins will automatically build and publish. After that, as long as you push to the Master branch, it will be automatically published.

Summarize

I simply recorded the whole process of my efforts. Jenkins and Docker have many more functions that need to be gradually understood during use.

This is the end of this article about the method and steps of Gogs+Jenkins+Docker automated deployment of .NetCore. For more related Docker automated deployment of .NetCore content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!