Learn to deploy microservices with docker in ten minutes

Since its release in 2013, Docker has been widely watched and considered to have the potential to change the software industry.

However, many people are not clear about what Docker is, what problems it solves, and what are its benefits? Today we will explain it in detail to help you understand it, and also provide easy-to-understand examples to teach you how to use it for daily development and deploy microservices.

1. Introduction to Docker

Docker is an open source container engine that helps deliver applications faster. Docker isolates the application and infrastructure layers and manages the infrastructure like a program. Using Docker can package, test, and deploy applications faster and shorten the cycle from writing to deploying and running code.

The advantages of Docker are as follows:

1. Simplify the process

Docker allows developers to package their applications and dependent packages into a portable container and then publish it to any popular Linux machine to achieve virtualization. Docker has changed the way virtualization is done, allowing developers to directly put their own results into Docker for management. Convenience and speed are already the biggest advantages of Docker. Tasks that used to take days or even weeks can now be completed in seconds using Docker containers.

2. Avoid the fear of choice

If you have a fear of making choices, you are a veteran patient. Docker helps you package your entanglement! For example, Docker images contain the operating environment and configuration, so Docker can simplify the deployment of multiple application instances. For example, Web applications, backend applications, database applications, big data applications such as Hadoop clusters, message queues, etc. can all be packaged into a mirror image for deployment.

3. Save money

On the one hand, the advent of the cloud computing era means that developers no longer need to configure expensive hardware in pursuit of results. Docker has changed the mindset that high performance must come at a high price. The combination of Docker and the cloud allows cloud space to be more fully utilized. It not only solves the problem of hardware management, but also changes the way of virtualization.

2. Docker Architecture

Docker daemon

Docker daemon is a background process running on the host machine (DOCKER-HOST). It can be communicated with through the Docker client.

Client

The Docker client is the user interface of Docker, which can accept user commands and configuration flags and communicate with the Docker daemon. In the figure, docker build and others are all Docker related commands.

Images

A Docker image is a read-only template that contains instructions for creating a Docker container. It is a bit like a system installation CD. You can use the system installation CD to install the system. Similarly, you can use the Docker image to run the program in the Docker image.

Container

A container is a runnable instance of an image. The relationship between images and containers is somewhat similar to the relationship between classes and objects in object-oriented programming. Containers can be started, stopped, moved, and deleted through Docker API or CLI commands.

Registry

Docker Registry is a service for centralized storage and distribution of images. After building the Docker image, you can run it on the current host. But if you want to run this image on other machines, you need to copy it manually. At this time, you can use Docker Registry to avoid manual copying of images.

A Docker Registry can contain multiple Docker repositories, each repository can contain multiple image tags, and each tag corresponds to a Docker image. This is somewhat similar to Maven's warehouse. If Docker Registry is compared to Maven's warehouse, then the Docker warehouse can be understood as the path of a jar package, and the image tag can be understood as the version number of the jar package.

3. Docker Installation

Docker is an open source commercial product with two versions: Community Edition (CE) and Enterprise Edition (EE). The enterprise version includes some paid services that are generally not used by individual developers. The following introduction is for the community version.

For installation of Docker CE, please refer to the official documentation. The following lists the installation methods for different operating systems

• Mac
• indows
• Ubuntu
• Debian
• CentOS
• Fedora
• Other Linux distributions

Here we take CentOS as an example:

1. Docker requires the kernel version of the CentOS system to be higher than 3.10. Check the prerequisites on this page to verify whether your CentOS version supports Docker.

Check your current kernel version with the uname -r command

# uname -r

2. Log in to CentOS with root privileges. Make sure the yum package is updated to the latest version.

# yum -y update

3. Uninstall the old version (if the old version has been installed)

# yum remove docker docker-common docker-selinux docker-engine

4. Install the required software packages. yum-util provides the yum-config-manager function. The other two are dependencies of the devicemapper driver.

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

5. Set up yum source

# yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

6. You can view all docker versions in all repositories and select a specific version to install

# yum list docker-ce --showduplicates | sort -r

7. Install Docker

# sudo yum install -y docker-ce #Since only the stable repository is enabled by default in the repo, the latest stable version 18.03.1 is installed here

8. Start and join the boot

# systemctl start docker

# systemctl enable docker

9. Verify whether the installation is successful (the presence of client and service parts indicates that the docker installation and startup are successful)

# docker version

10. Uninstall Docker

# yum -y remove docker-engine

4. Common Docker commands

(I) .Mirror related commands

1. Search for images

You can use the docker search command to search for images stored in Docker Hub (this is the official place provided by Docker to store all Docker image software, similar to Maven's central warehouse). After executing this command, Docker will search for image repositories containing the keyword java in Docker Hub.

# docker search java

The above list contains five columns, with the following meanings:

• NAME: The name of the image repository.
• DESCRIPTION: Description of the image repository.
• STARS: The number of collections of the mirror repository, indicating the popularity of the mirror repository, similar to GitHub's stars0
• OFFICAL: Indicates whether it is an official repository. The images marked with [0K] in this column are created and maintained by the official project team of each software.
• AUTOMATED: Indicates whether it is an automatically built image repository.

Note: Using docker to find or download images may time out, so we need to configure a domestic image accelerator for docker

We can use Alibaba Cloud's image accelerator to log in to Alibaba Cloud (https://cr.console.aliyun.com/#/accelerator)

You can see the mirror acceleration address as shown below:

# cd /etc/docker

Check if there is daemon.json. This is the default Docker configuration file.

If not, create a new one; if so, modify it.

# vim daemon.json 
{
  "registry-mirrors": ["https://m9r2r2uj.mirror.aliyuncs.com"]
}

Save, exit and restart the Docker service

# service docker restart

2. Download the image

Use the docker pull command to download the image from the Docker Registry. After executing the command, Docker will download the latest version of the Java image from the java repository in the Docker Hub. If you want to download a specific version, add a colon after java to specify the version, for example: docker pull java:8

# docker pull java:8

3. List images

Use the docker images command to list the downloaded images

# docker images

The above list means the following:

• REPOSITORY: The name of the repository to which the image belongs.
• TAG: Image tag. The default is latest, which means the latest.
• IMAGE ID: image ID, which indicates the unique identifier of the image.
• CREATED: The image creation time.
• SIZE: Image size.

4. Delete the local image

Use the docker rmi command to delete the specified image

# docker rmi java

(II) Container related commands

1. Create and start a container

Use the following docker run <image name> command to create and start a container. This command is the most commonly used command and has many options. Some commonly used options are listed below.

# docker run -d -p 91:80 nginx

This will start an Nginx container. In this example, two parameters are added to docker run with the following meanings:

• -d Run in the background
• -p host port:container port #Open container port to host port

Visit http://Docker host IP:91/, you will see the main interface of nginx as follows:

It should be noted that when using the docker run command to create a container, it will first check whether the specified image exists locally. If the image with this name does not exist locally, Docker will automatically download the image from Docker Hub and start a Docker container.

The command also has a network configuration parameter, as shown below

• --net option: Specifies the network mode. This option has the following optional parameters:
• --net=bridge: The default option means connecting to the default bridge.
• --net=host: The container uses the host's network.
• --net=container:NAME-or-ID: Tells Docker to use the network configuration of an existing container for the newly created container.
• --net=none: Do not configure the network of this container. Users can customize the network configuration.

2. List containers

Use the docker ps command to list the running containers

# docker ps

To list all containers (including stopped ones), use the -a parameter. The list contains 7 columns, the meanings are as follows

• CONTAINER_ID: indicates the container ID.
• IMAGE: indicates the image name.
• COMMAND: Indicates the command to run when starting the container.
• CREATED: Indicates the creation time of the container.
• STATUS: Indicates the running status of the container. UP means it is running, and Exited means it has stopped.
• PORTS: indicates the external port number of the container.
• NAMES: indicates the container name. The name is automatically generated by Docker by default, but you can also specify it yourself using the --name option of the docker run command.

3. Stop the container

Use the docker stop <container id> command to stop the container.

# docker stop f0b1c8ab3633

f0b1c8ab3633 is the container ID. You can also use docker stop to stop the specified container.

4. Force stop the container

You can use the docker kill <container id> command to send a SIGKILL signal to force stop the container

# docker kill f0b1c8ab3633

5. Start a stopped container

Use the docker run command to create and start a container. For a stopped container, you can use the docker start <container id> command to start it

# docker start f0b1c8ab3633

6. View all container information

Use the command docker inspect <container id>

# docker inspect f0b1c8ab3633

7. View container logs

Use the command docker container logs <container id>

# docker container logs f0b1c8ab3633

8. View the process in the container

Use the command docker top <container id>

# docker top f0b1c8ab3633

9. Enter the container

Use the docker container exec -it <container id> /bin/bash command to enter a running docker container. If the -it parameter is not used when the docker run command runs the container, this command must be used to enter the container. Once inside the container, you can execute commands in the container's Shell

# docker container exec -it f0b1c8ab3633 /bin/bash

10. Delete the container

Use the docker rm command to delete the specified container

# docker rm f0b1c8ab3633

This command can only delete stopped containers. To delete a running container, use the -f parameter.

(III) Build your own Docker image

Build your own Docker image using Dockerfile

Dockerfile is a text file that contains several instructions that describe the details of building an image.

Let's write the simplest Dockerfile first. Taking the Nginx image downloaded in the previous article as an example, let's write a Dockerfile to modify the homepage of the Nginx image.

1. Create a new folder /app, create a new file named Dockerfile in the app directory, and add the following content to it:

FROM nginx #Pull ngxin's docker image from the local image repository RUN echo 'This is QingFeng Nginx!!!' > /usr/share/nginx/html/index.html #Modify the homepage content of ngxin's docker image

The Dockerfile is very simple, and FORM and RUN are both instructions of the Dockerfile. The FROM instruction is used to specify the base image, and the RUN instruction is used to execute commands.

2. Execute the following command in the path where Dockerfile is located to build our own ngxin image. After building, you can use the docker images command to check whether the image ngxin:tuling has been generated:

# docker build -t nginx:qingfeng .

Among them, -t specifies the image name, and the dot (.) at the end of the command indicates the path where the Dockerfile file is located.

3. Execute the following command to start a Docker container using this image

# docker run -d -p 92:80 nginx:qingfeng

4. Visit http://Docker host IP:92/, and you can see the interface shown in the figure below.

Dockerfile file writing also has the following common instructions

Note: The RUN command is executed during the image file building phase, and the execution results are packaged into the image file; the CMD command is executed after the container is started. In addition, a Dockerfile can contain multiple RUN commands, but only one CMD command.

Note: After specifying the CMD command, the docker container run command cannot be appended with a command (such as /bin/bash in the previous command), otherwise it will overwrite the CMD command.

(IV) Using Dockerfile to build microservice images

Take the spring boot project ms-eureka-server (source code at the end) as an example. This project is a spring cloud eureka microservice project. The project can be packaged into an executable jar package and run through the spring boot maven plug-in, as shown in the following figure

Build the executable jar package of the project into a docker image:

1. Upload the jar package to the /app/eureka directory of the Linux server, and create a file named Dockerfile in the directory where the jar package is located.

2. Add the following content to Dockerfile

# 基于哪個鏡像

From java:8

# 復制文件到容器

ADD microservice-eureka-server-0.0.1-SNAPSHOT.jar /app.jar

# 聲明需要暴露的端口

EXPOSE 8761 #Startup port of the microservice project

# 配置容器啟動后執行的命令

ENTRYPOINT ["java","-jar","/app.jar"]

3. Use the docker build command to build the image

# docker build -t microservice-eureka-server:0.0.1 .

# 格式： docker build -t 鏡像名稱:標簽Dockerfile的相對位置

Here, the image tag is specified using the -t option. After executing this command, the terminal will output the following

4. Start the image, add -d to start in the background

# docker run -p 8761:8761 microservice-eureka-server:0.0.1

5. Visit http://Docker host IP:8761/, and the homepage of the microservice Eureka Server can be displayed normally.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.