Docker image creation, uploading, pulling and deployment operations (using Alibaba Cloud)

Since I found that the push image always timed out during the learning process, I directly applied for a Docker repository on Alibaba Cloud (Management Center -> Create Mirror Repository -> Mine is East China 2, just bind the GitHub account), done! In the future, push using this repository, use the accelerator when pulling, pay attention to switch according to the usage scenario, discard dockerhub... record the operation process:

1. Create a namespace hhu (based on the current school, can only be lowercase, each account can only create 5), create the rookie Docker image warehouse docker1 (bind to a warehouse in github, individuals can use it at will, this warehouse image is like an app, you can continuously update its version), then all test images can be pushed here, and other image warehouses can be applied for other special images in the future (for example, when making Tomcat, apply for a separate image warehouse tomcat, when making redis, apply for a redis warehouse, and so on). Finish;

2. Mirror image production, this step is separately recorded in detail below;

3. Image push: After the production is completed, the image needs to be pushed to docker1 in the image test warehouse. The basic information is as follows –

1. Public network address: registry.cn-shanghai.aliyuncs.com/hhu/docker1

2. Intranet address (optional for ECS): registry-internal.cn-shanghai.aliyuncs.com/hhu/docker1

3. Code repository (i.e. the bound repository on GitHub): https://github.com/Jacksonary/Docker

My first Docker image is named jacksonary/myfirstapp. I choose to push it to the public network based on the network conditions. The main process is as follows:

# 1. Switch from the accelerator to the warehouse address to log in docker login [email protected] registry.cn-shanghai.aliyuncs.com

# 2. Create a tag for the image based on its name or ID. The default is latest docker tag jacksonary/myfirstapp registry.cn-shanghai.aliyuncs.com/hhu/docker1[:image version number]

# 3. Push the image docker push registry.cn-shanghai.aliyuncs.com/hhu/docker1[:image version number]

You can then view the pushed image in the Alibaba Cloud warehouse as follows:

When obtaining the above image file, you need to specify the image version number, so it is recommended to add the required image version number to distinguish it when pushing the image. If I need to pull the above image, I can do the following:

# Because the default version is latest, you can leave it blank when getting it, or add: latest (recommended) docker pull registry.cn-shanghai.aliyuncs.com/hhu/docker1

1. Production of Docker Image

Generally, one project is placed in one folder. For example, there is a project called flask-app on the official website, so all the files are in the project directory. We need to add a text file called "Dockerfile" in the project root directory, remove its txt suffix, and then use a common text editor to write the Docker environment, such as the following Dockerfile:

# 1. Specify the base image as Linux (alipine Docker image is a lightweight Linux system of only 5M)
FROM alpine:3.5

# Install python and pip under alipine. This app is written in Python, so you need to install the Python environment, usually by copying files and installing dependencies. RUN apk add --update py2-pip

# Install the required Python COPY requirements.txt required by the app /usr/src/app/
RUN pip install --no-cache-dir -r /usr/src/app/requirements.txt

# Copy the files required by the application to the image COPY app.py /usr/src/app/
COPY templates/index.html /usr/src/app/templates/

# Set the port number to be exposed EXPOSE 5000

# Set the application to start the Python application through cmd CMD ["python", "/usr/src/app/app.py"]

Then create a Docker image, enter the project root directory (where the Dockerfile is located) with PowerShell, and execute

docker build -t jacksonary/myfirstapp .

It should be noted here that when we use "Dockerfile" as the Docker configuration file name, we can write it directly, but if we use other configuration file names, we must specify them additionally. For example, if we refer to "jdk-9-alpine.Dockerfile" as the Docker configuration file, we should use -f to specify the configuration file and write it like this:

docker build -t jacksonary/myfirstapp -f jdk-9-alpine.Dockerfile .

The -t command labels the currently created image as "jacksonary/myfirstapp". The first half of / must be your Docker user ID (if you are using the Dockerhub repository, Dockerhub defaults to your user name. If you are using Alibaba Cloud, I can choose any name). The second half of / is the name of the application. Together, they are used as the tag of the image. The URL path behind it cannot be lost. The dot indicates the current path. After execution, it will be automatically published to the current HV virtual machine. Using docker images, you can see that there is an additional "jacksonary/myfirstapp" image. This completes the process.

[Summary] Regarding the Dockerfile file configuration, you need to:

1. The Dockerfile file must start with FROM, followed by the base container and version, indicating the parent container of the current image. The parent container usually exists in the form of "user name/image name: version number" (this is the same in Dockerhub)

2. The RUN instruction is used to create the current Docker image. Each time this instruction is called, Docker will create a new image layer, which makes it easier to roll back to the previous image version. Its syntax is to follow the RUN with a shell instruction (such as RUN mkdir /user/local/foo), which will automatically execute the /bin/sh shell. Of course, you can also specify, for example: RUN /bin/bash -c 'mkdir /user/local/foo'

3. The COPY instruction can copy local files to the container

4. The command defined by the CMD instruction will be executed when the image is started. Unlike the RUN instruction, it does not create a new image layer, but simply executes the instruction. In each image's Dockerfile file, there can be only one CMD instruction or multiple instructions to be executed (in this case, it is best to run CMD as a script). When CDM executes instructions, we need to specify where to run these instructions, while RUN does not need to specify, such as the following CMD instruction

CMD ["python", "./app.py"]

CMD ["/bin/bash", "echo", "Hello World"]

5. The EXPOSE instruction is used to specify the port on which the image program will provide services. This information can be retrieved through the docker inspect <container-id> instruction, but the EXPOSE instruction does not actually expose the port to the host. Instead, it needs to be exposed with the -p flag when publishing with docker run. The lowercase p above needs to specify the mapping between the host to the virtual to the host port, while the uppercase P exposes the port in the image to a random port on the host. The specific port exposed can be viewed through docker ps, for example:

As can be seen in the figure above, the mirrored port 8080 is exposed to the host's port 32768, which can be viewed through localhost:32768.

6. The PUSH command can publish the image to platforms such as Docker Cloud

7. The ENV instruction is used to configure environment variables, such as:

# Configure Java environment variables, which are standard JAVA environment variables in Linux ENV JAVA_HOME=/opt/jdk-9
ENV PATH=$PATH:$JAVA_HOME/bin

2. Deploy and run the image

After creating the image, you can run it. Here is the image I made according to the tutorial: docker pull registry.cn-shanghai.aliyuncs.com/hhu/docker1, which can be pulled down and run in Docker:

docker pull registry.cn-shanghai.aliyuncs.com/hhu/docker1

docker run -p 8888:5000 --name myfirstapp registry.cn-shanghai.aliyuncs.com/hhu/docker1

The -p directive (this is very important) means mapping the exposed port 5000 on the virtual machine to the local port 8888, and naming the image myfirstapp. You can view the git map of cats by visiting http://localhost:8888. Each refresh will randomly obtain a different cat map.

3. Image push

The entire Docker image file address is at the beginning of the article: https://github.com/Jacksonary/Docker/tree/master/flask-app

4. Deployment of simple JAVA applications

It is a simple Java project, which is packaged using Maven. Let's go to our working directory and execute

mvn archetype:generate -DgroupId=edu.hhu.java -DartifactId=helloworld -DinteractiveMode=false

Create a simple Maven Java project. I know that most people can execute this successfully, but a small number of people cannot create a project by executing this command (I am one of them).

There is no POM in this directory

I gave him an empty pom with a confused look on my face, and it prompted that there was no data in the pom. Well, let's do it in a different way. Let's tell him that we want to create a project:

mvn archetype:generate

Then it will prompt us whether we want the built-in skeleton, select 7: maven-archetype-quickstart, and then enter the groupID and artifactId information according to the prompts. Finally, it will ask you whether you want to package, just package (then the jar package will appear in the target directory), Okay, this step is done, see if this project can be used:

java -cp target/helloworld-1.0-SNAPSHOT.jar edu.hhu.java.App

Among them, -cp specifies the package path of all classes required to execute this class file - that is, the path of the system class loader. The default skeleton will give "Hello World" to greet you. OK, the Java project is created.

The second step is to write the Docker configuration file Dockerfile:

FROM openjdk:latest

COPY target/helloworld-1.0-SNAPSHOT.jar /usr/src/helloworld-1.0-SNAPSHOT.jar

CMD java -cp /usr/src/helloworld-1.0-SNAPSHOT.jar edu.hhu.java.App

The third step is to create a mirror and execute

docker build -t jacksonary/helloworld .

docker run jacksonary/helloworld

4. Complex multi-container applications in Docker (Docker-compose)

In actual development, multiple services are often required, not just printing a sentence in Ubuntu, such as interacting with a database in the WEB. Such applications are typically composed of multiple containers. There is no need to use a shell to start these containers. All containers will be defined in a configuration file as a "service group", similar to Dockerfile, written in the project root directory, and then can be used

docker-compose up -d

The docker-compose script can be used to start, stop, and restart the application and all the services in the application. The complete command of docker-compose is as follows:

The entry point for these Docker component services defined together is the docker-compse configuration file, which usually exists in the form of a yml file, such as the following docker-compse.yml (note that a space must be added after the colon when configuring each property, except for port mapping):

version: '3.3'
services:
 db:
 container_name: db
 image:mysql:8
 environment:
  MYSQL_DATABASE: employees
  MYSQL_USER: mysql
  MYSQL_PASSWORD: mysql
  MYSQL_ROOT_PASSWORD: supersecret
 ports:
  - 3307:3306
 web:
 image: arungupta/docker-javaee:dockerconeu17
 ports:
  -8081:8080
  -9991:9990
 depends_on:
  -db

In the above combined file:

1. Define two services: db and web

2. The image attribute specifies the image file for each service word

3. The mysql:8 image will start the MySql service

4. The environment attribute defines the MySQL service environment variables for initialization: MYSQL_DATABASE is used to create a database with a specified name when the image is started. MYSQL_USER and MYSQL_PASSWORD are combined to create a new user and set a password. This user will be granted super privileges on the database created by MYSQL_DATABASE. MYSQL_ROOT_PASSWORD is mandatory to set the MySQL super user password.

5. ports implement port forwarding, the front one is the host, the back one is the virtual machine

6. The depends_on attribute indicates the dependency between two services. In this case, WildFly (an application server) depends on MySQL, so MySQL will be started before WildFly.

After having the above combined configuration file, PW enters the directory where the file is located, and then uses docker-compose up -d to start the two services in isolation mode. docker ps can view the mapping between ports, and it can also be found that two containers are started. docker-compose logs can view the service logs. At this time, we can access all personnel information through http://localhost:8081/resources/employees and stop this group of services:

docker-compose down

The above article on making, uploading, pulling and deploying Docker images (using Alibaba Cloud) is all I want to share with you. I hope it can give you a reference. I also hope that you will support 123WORDPRESS.COM.