docker的安裝及項目部署

Making Docker and Deployment Process

Step:

　　set up your docker environment

　　build a image of activeMQ with Dockerfile

　　build a image of swieApp with Dockerfile

　　delploy your project with docker-compose.yml

一.Set up your docker environment

　　Install Docker CE Offline

　　　　1.Download three packages:containerd.io_1.2.4-1_amd64.deb，docker-ce-cli_18.09.3_3-0_ubuntu-bionic_amd64.deb，docker-ce_18.09.3_3-0_ubuntu-bionic_amd64.deb from https://download.docker.com/linux/ubuntu/dists/bionic/pool/stable/amd64/
　　　　2.Install containerd.io
　　　　　　$ sudo apkg -i containerd.io_1.2.4-1_amd64.deb
　　　　3.Install docker client
　　　　　　$ sudo apkg -i docker-ce-cli_18.09.3_3-0_ubuntu-bionic_amd64.deb
　　　　4.Install docker server
　　　　　　$ sudo apkg -i docker-ce_18.09.3_3-0_ubuntu-bionic_amd64.deb
　　　　5.Check if docker is installed successfully
　　　　　　$ sudo docker -v #Just check if the docker-ce-cli client package is installed successfully.
　　　　　　$ sudo socker images #View the local image, if the error is reported, the installation is not successful.
　　　　　　$ sudo docker run hello-world #Check online if docker is installed successfully.

　　Install Docker CE Online

　　Before you install Docker CE for the first time on a new host machine, you need to set up the Docker repository. Afterward, you can install and update Docker from the repository.

　　1.SET UP THE REPOSITORY

　　　　1. Update the apt package index:

　　　　　　$ sudo apt-get update

　　　　2. Install packages to allow apt to use a repository over HTTPS:

　　　　　　$ sudo apt-get install \

　　　　　　apt-transport-https \

　　　　　　ca-certificates \

　　　　　　curl \

　　　　　　gnupg-agent \

　　　　　　software-properties-common

　　　　3. Add Docker’s official GPG key:

　　　　　　$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

　　　　　　(Verify that you now have the key with the fingerprint 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88, by searching for the last 8 characters of the fingerprint.

　　　　　　$ sudo apt-key fingerprint 0EBFCD88

　　　　　　　　pub 4096R/0EBFCD88 2017-02-22

　　　　　　　　Key fingerprint = 9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88

　　　　　　　　uid Docker Release (CE deb) <docker@docker.com>

　　　　　　　　sub 4096R/F273FCD8 2017-02-22)

　　　　4. Use the following command to set up the stable repository.

　　　　　　$ sudo add-apt-repository \

　　　　　　　　"deb [arch=amd64] https://download.docker.com/linux/ubuntu \

　　　　　　　　$(lsb_release -cs) \

　　　　　　　　stable"

　　2.INSTALL DOCKER CE

　　　　1. Update the apt package index.

　　　　　　$ sudo apt-get update

　　　　2. Install the latest version of Docker CE, or go to the next step to install a specific version:

　　　　　　$ sudo apt-get install docker-ce

　　　　3. To install a specific version of Docker CE, list the available versions in the repo, then select and install:

　　　　　　a. List the versions available in your repo:

　　　　　　　　$ apt-cache madison docker-ce

　　　　　　b. Install a specific version using the version string from the second column, for example, 5:18.09.1~3-0~ubuntu-xenial.

　　　　　　　　$ sudo apt-get install docker-ce=5:18.09.1~3-0~ubuntu-xenial

　　　　4. Verify that Docker CE is installed correctly by running the hello-world image.

　　　　　　$ sudo docker run hello-world

　　　　(This command downloads a test image and runs it in a container. When the container runs, it prints an informational message and exits.)

二.Build a image of activeMQ with Dockerfile

　　1. Edit Dockerfile

　　Create an empty directory. Change directories (cd) into the new directory, create a file called Dockerfile, copy-and-paste the following content into that file, and save it. Take note of the comments that explain each statement in your new Dockerfile.

　　　　# Use an official jdk runtime as a parent image

　　　　FROM openjdk:8

　　　　# Copy the current directory contents into the container at /usr/src/apache

　　　　COPY . /usr/src/apache

　　　　# Set the working directory to /usr/src/apache

　　　　WORKDIR /usr/src/apache

　　　　# Make port 1884/61616/8161/5672/61613/1883/61614 available to the world outside this container

　　　　EXPOSE 1884

　　　　EXPOSE 61616

　　　　EXPOSE 8161

　　　　EXPOSE 5672

　　　　EXPOSE 61613

　　　　EXPOSE 1883

　　　　EXPOSE 61614

　　　　# Start the activemq service when the container launches

　　　　ENTRYPOINT ./apache-activemq-5.15.3/bin/linux-x86-64/activemq start && /bin/bash

　　This Dockerfile refers to a package of apache-activemq-5.15.3 we haven’t created yet, namely apache-activemq-5.15.3. Let’s create it next.

　　2. Copy the package of activemq to the current directory

　　Put the package of activemq in the same folder with the Dockerfile. This completes our service of activemq, which as you can see is quite simple. When the above Dockerfile is built into an image, apache-activemq-5.15.3 is present because of that 　　　Dockerfile’s COPY command, and the output from activemq is accessible over HTTP thanks to the EXPOSE command.

　　3. Build the app into a image

　　　　a. We are ready to build the app. Make sure you are still at the top level of your new directory. Here’s what ls should show:

　　　　　　$ ls

　　　　　　Dockerfile apache-activemq-5.15.3

　　　　b. Now run the build command. This creates a Docker image, which we’re going to name using the --tag option. Use -t if you want to use the shorter option.

　　　　　　$ docker build --tag=activemq . (dont't forget the dot ".", this means make it in the current directory)

　　　　c. Where is your built image? It’s in your machine’s local Docker image registry:

　　　　　　$ docker image ls

　　　　　　　　REPOSITORY TAG IMAGE ID

　　　　　　　　activemq latest 326387cea398

　　　　Note how the tag defaulted to latest. The full syntax for the tag option would be something like --tag=activemq:v0.0.1.

　　　　4. Test whether the image was created successfully

　　　　We test whether the image was created successfully by creating a container.

　　　　　　a. Now let’s run the app in the background, in detached and interactive mode:

　　　　　　　　$ docker run -d -i -p 4000:1884 activemq

　　　　　　　　　　-i --interactive Keep STDIN open even if not attached

　　　　　　　　　　-d --detach Run container in background and print container ID

　　　　　　　　　　-p --publish-all Publish all exposed ports to random ports

　　　　　　b. You get the long container ID for your app and then are kicked back to your terminal. Your container is running in the background. You can also see the abbreviated container ID with docker container ls (and both work interchangeably when running commands):

　　　　　　　　$ docker container ls

　　　　　　　　　　CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

　　　　　　　　　　9979d09fe820 activemq "/bin/sh -c './apach…" 6 seconds ago Up 5 seconds 1883/tcp, 5672/tcp, 8161/tcp, 61613-61614/tcp, 61616/tcp, 0.0.0.0:4000->1884/tcp vigorous_galileo

　　　　　　c. Now use docker container stop to end the process, using the CONTAINER ID, like so:

　　　　　　　　$ docker container stop 9979d09fe820

　　So far, we have successfully created a image of activemq and successfully run it by a container. If you want to share your image, you can take the following steps.

　　Share your image

　　　　To demonstrate the portability of what we just created, let’s upload our built image and run it somewhere else. After all, you need to know how to push to registries when you want to deploy containers to production.

　　　　A registry is a collection of repositories, and a repository is a collection of images—sort of like a GitHub repository, except the code is already built. An account on a registry can create many repositories. The docker CLI uses Docker’s public registry by default.

　　　　1. Log in with your Docker ID

　　　　　　$ docker login

　　　　2. Tag the image

　　　　　　$ docker tag image username/repository:tag

　　　　　　for example: $ docker tag activemq haizeiwang/activemq:v1

　　　　　　　　　　　　　　-haizeiwang is my account name

　　　　　　　　　　　　　　-activemq is my remote repository name

　　　　　　　　　　　　　　-v1 is my image tag,which is the version number

　　　　3. Publish the image

　　　　　　$ docker push username/repository:tag

　　　　Once complete, the results of this upload are publicly available. If you log in to Docker Hub, you see the new image there, with its pull command.

　　　　4. Pull and run the image from the remote repository

　　　　　　$ docker run -p 4000:1884 haizeiwang/activemq:v1

　　　　If the image isn’t available locally on the machine, Docker pulls it from the repository.

　　　　No matter where docker run executes, it pulls your image, along with jdk , and runs your code. It all travels together in a neat little package, and you don’t need to install anything on the host machine for Docker to run it.

三.Build a image of swieApp with Dockerfile

　　Repeat the second step,but omit running and sharing.

　　1. Edit the Dockerfile

　　　　FROM python:3.7

　　　　ENV PYTHONUNBUFFERED 1

　　　　RUN echo python -V

　　　　RUN mkdir /app

　　　　RUN mkdir /app/db

　　　　COPY . /app

　　　　WORKDIR /app/SwieProject

　　　　RUN pip3 install -r ../requirements.txt

　　　　EXPOSE 8080

　　　　ENTRYPOINT python ./wanlidaserver.py

　　(This Dockerfile refers to a couple of files we haven’t created yet, namely wanlidaserver.py and requirements.txt. Let’s create those next.)

　　2. Create a file named requirements.txt

　　　　This file provides all the packages that the project needs that Python does not have. When executing the "RUN pip3 install -r ../requirements.txt" command, all the packages in the file will be installed. Put it in the same folder with the Dockerfile. The file contents are as follows:

　　　　　　pymysql

　　　　　　DBUtils

　　　　　　sanic

　　　　　　paho-mqtt

　　　　　　pandas

　　　　　　xlwt

　　　　　　qrcode

　　　　　　zplgrf

　　　　　　xlutils

　　　　　　requests

　　　　　　DBUtils

　　3. Create your python project

　　　　Since we have created the project through pycharm, copy the entire project directly to the same folder with the Dockerfile. We named the project SwieProject. The executable file wanlidaserver.py is in the project directory SwieProject. When executing the "WORKDIR /app/SwieProject" command, set "/app/SwieProject" to the working directory of the container. So we can execute the file wanlidaserver.py in the current directory.

　　4. We are ready to build the app. Make sure you are still at the top level of your new directory. Here’s what ls should show:

　　　　$ ls

　　　　　　Dockerfile requirements.txt SwieProject

　　5. Now run the build command to create a Docker image of swieApp

　　　　$ docker build -t swieApp .

　　Here we have successfully created a swieApp image. And I have already shared it with my remote repository and will use it when deploying the app. The image name is haizeiwang/wanlida_server:v1

四.Delploy your project with docker-compose.yml

　　1. Edit the docker-compose.yml

　　　　A docker-compose.yml file is a YAML file that defines how Docker containers should behave in production.Content is as follows:

　　　　　　version: "3" # Use version 3

　　　　　　services: # The service to be established by the project

　　　　　　　　db: # The name of the database service

　　　　　　　　　　image: mysql:5.7 # Use the official mysql database image, 5.7 is the version number

　　　　　　　　　　expose:

　　　　　　　　　　　　- "3306" # Make port 3306 available to the world outside this container

　　　　　　　　　　volumes: # Volumes are the preferred mechanism for persisting data generated by and used by Docker containers.

　　　　　　　　　　　　- ./db:/var/lib/mysql # Persist the data of the container mysql to the host db directory

　　　　　　　　　　ports:

　　　　　　　　　　　　- "4000:3306" # Map container 3306 port to host 4000 port

　　　　　　　　　　environment: # What the database initialization process needs to do

　　　　　　　　　　　　- MYSQL_DATABASE=Swissmic_WMS # Create a database called Swissmic_WMS

　　　　　　　　　　　　- MYSQL_ROOT_PASSWORD=root # Set the root account password to root

　　　　　　　　　　　　- MYSQL_USER=swie # Create a user with a database named Swie

　　　　　　　　　　　　- MYSQL_PASSWORD=xiaomanniubi123 # Set the password for the Swie user as xiaomanniubi123

　　　　　　　　　　depends_on: # Control startup sequence

　　　　　　　　　　　　- activemq # Start after the activemq service starts

　　　　　　　　activemq: # The name of the activeMQ service

　　　　　　　　　　image: haizeiwang/activemq:v1 # Use the image we created earlier

　　　　　　　　　　volumes:

　　　　　　　　　　　　- ./activeMQ:/var/lib/activeMQ # Persist the data of the container activeMQ to the host activeMQ directory

　　　　　　　　　　stdin_open: yes # Keep the service up and running. Note: The "yes" can be changed to "true".

　　　　　　　　　　tty: yes # Keep in terminal output

　　　　　　　　　　privileged: yes # Make the root of the container have root privileges on the external host, otherwise it is just a normal user right of the external host.

　　　　　　　　　　ports:

　　　　　　　　　　　　- "1884:1884" # Map container 1884 port to host 1884 port

　　　　　　　　web: # The name of the web project service

　　　　　　　　　　image: haizeiwang/wanlida_server:v1 # Use the wanlida_server image we created earlier

　　　　　　　　　　ports:

　　　　　　　　　　　　- "8080:8080" # Map container 8080 port to host 8080 port

　　　　　　　　　　links: # Command to connect to other services. The parameter directly uses the name of the service.

　　　　　　　　　　　　- db # Command to connect to database service

　　　　　　　　　　　　- activemq # Command to connect to activeMQ service

　　　　　　　　　　depends_on:

　　　　　　　　　　　　- db # Start after the db service starts

　　2. Deploy application services

　　　　The whole file means that the entire project needs to start three services, the startup sequence is activemq>db>web,the web is the last one started and must be the last one.Next we have two ways to run this yml file, which is to deploy the application service.

　　　　Method 1: Use the docker-compose command

　　　　　　a. Create and start services

　　　　　　　　$ docker-compose up

　　　　　　Note:If you follow the steps, the database and activeMQ service will start successfully, but you will encounter the problem that the web service fails to start because it cannot connect to the database. This is because you create a database service without data, you need to import the database table structure and data that have been created locally into the Swissmic_WMS database.Do not close the service that has already been started, and then open another terminal.

　　　　　　　　1.Export the local Swissmic_WMS database data to the db.sql file in the current directory.

　　　　　　　　　　$ mysqldump -uroot -proot Swissmic_WMS >./db.sql

　　　　　　　　2. Make sure you are still at the top level of your new directory. Here’s what ls should show:

　　　　　　　　　　$ ls

　　　　　　　　　　　　activeMQ db docker-compose.yml db.sql

　　　　　　　　3. View information about running containers.

　　　　　　　　　　$ docker ps

　　　　　　　　　　　　CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

　　　　　　　　　　　　2fea493b0104 mysql:5.7 "docker-entrypoint.s…" 4 days ago Up 2 hours 33060/tcp, 0.0.0.0:4000->3306/tcp wanlidaapp_db_1

　　　　　　　　　　　　129c12684fc8 haizeiwang/activemq:v1 "/bin/sh -c './apach…" 4 days ago Up 2 hours 1883/tcp, 5672/tcp, 8161/tcp, 61613-61614/tcp, 61616/tcp, 0.0.0.0:1884->1884/tcp wanlidaapp_activemq_1

　　　　　　　　4. Import the db.sql file into the db container

　　　　　　　　　　$ docker cp db.sql wanlidaapp_db_1:/root/ (Note:"wanlidaapp_db_1" is the container name,you can also change to the container ID.)

　　　　　　　　5. Go into the container that runs the database

　　　　　　　　　　$ docker exec -ti 2fea493b0104 bash

　　　　　　　　6. Switch to the root directory.

　　　　　　　　　　$ cd /root

　　　　　　　　7. Import the db.sql file into the Swissmic_WMS database in the container

　　　　　　　　　　$ mysql -u root -p Swissmic_WMS < db.sql

　　　　　　　　8. Test data is imported successfully

　　　　　　　　　　$ mysql -u root -p root

　　　　　　　　　　　　>> use Swissmic_WMS;

　　　　　　　　　　　　>> show tables;

　　　　　　　　　　If you see the table you want, congratulations, the data import is successful. Otherwise, it is necessary to check from the first step.

　　　　　　　　　　　　>> exit;

　　　　　　　　9. Exit the container

　　　　　　　　　　$ exit

　　　　　　b. Stop the services

　　　　　　　　$ docker-compose stop

　　　　　　c. Update and run again

　　　　　　　　$ docker-compose up

　　　　　　d. View a running container on another terminal

　　　　　　　　$ docker ps

　　　　　　　　　　CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES

　　　　　　　　　　9cb77a4c2732 haizeiwang/wanlida_server:v3 "/bin/sh -c 'python …" About a minute ago Up 17 seconds 0.0.0.0:8080->8080/tcp wanlidaapp_web_1

　　　　　　　　　　2fea493b0104 mysql:5.7 "docker-entrypoint.s…" 4 days ago Up 18 seconds 33060/tcp, 0.0.0.0:4000->3306/tcp wanlidaapp_db_1

　　　　　　　　　　129c12684fc8 haizeiwang/activemq:v1 "/bin/sh -c './apach…" 4 days ago Up 19 seconds 1883/tcp, 5672/tcp, 8161/tcp, 61613-61614/tcp, 61616/tcp, 0.0.0.0:1884->1884/tcp wanlidaapp_activemq_1

　　　　　　Note: If the above result is displayed, it means that all the startups have been successful. You can enter http://localhost:8080/wms in the browser to test whether the login page appears.

　　　　So far, we have successfully deployed the project service using Method 1. In order to facilitate the direct use of database image in the future, we will recreate a database image using the database container that is running now. Proceed as follows:

　　　　　　1. Stop the services

　　　　　　　　$ docker-compose stop

　　　　　　2. Convert the database container to a image

　　　　　　　　$ sudo docker commit -m "Describe the changed information" -a "author information" 2fea493b0104 haizeiwang/mysql:v1

　　　　　　3. Upload the image to your remote repository

　　　　　　　　$ docker push haizeiwang/mysql:v1

　　　　We will use Method 2 to redeploy the service.

　　　　Method 2: Use the docker stack deploy command

　　　　　　1. Before we can use the docker stack deploy command we first edit the docker-compose.yml file like this:

　　　　　　　　version: "3"

　　　　　　　　services:

　　　　　　　　　　db:

　　　　　　　　　　　　image: haizeiwang/mysql:v1

　　　　　　　　　　　　expose:

　　　　　　　　　　　　　　- "3306"

　　　　　　　　　　　　volumes:

　　　　　　　　　　　　　　- ./db:/var/lib/mysql

　　　　　　　　　　　　ports:

　　　　　　　　　　　　　　- "4000:3306"

　　　　　　　　　　　　depends_on:

　　　　　　　　　　　　　　- activemq

　　　　　　　　　　activemq:

　　　　　　　　　　　　image: haizeiwang/activemq:v1

　　　　　　　　　　　　volumes:

　　　　　　　　　　　　　　- ./activeMQ:/var/lib/activeMQ

　　　　　　　　　　　　stdin_open: yes

　　　　　　　　　　　　tty: yes

　　　　　　　　　　　　privileged: yes

　　　　　　　　　　　　ports:

　　　　　　　　　　　　　　- "1884:1884"

 

　　　　　　　　　　web:

　　　　　　　　　　　　image: haizeiwang/wanlida_server:v1

　　　　　　　　　　　　ports:

　　　　　　　　　　　　　　- "8080:8080"

　　　　　　　　　　　　links:

　　　　　　　　　　　　　　- db

　　　　　　　　　　　　　　- activemq

　　　　　　　　　　　　depends_on:

　　　　　　　　　　　　　　- db

　　　　　　2. Create a node of swarm manager, here we use the host as a swarm manager

　　　　　　　　$ docker swarm init

　　　　　　3. Now let’s deploy the project. You need to give your app a name. Here, it is set to SwieApp:

　　　　　　　　$ docker stack deploy -c docker-compose.yml SwieApp

　　　　　　Note:If you follow the steps, the database and activeMQ service will start successfully, but you will encounter the problem that the web service fails to start because it cannot connect to the database. This is because you create a database service without data, you need to import the database table structure and data that have been created locally into the Swissmic_WMS database.Do not close the service that has already been started, and then open another terminal.

　　　　　　　　1. Go into the container that runs the database

　　　　　　　　　　$ docker exec -ti container’s ID bash

　　　　　　　　2. Switch to the root directory.

　　　　　　　　　　$ cd /root

　　　　　　　　3. Import the db.sql file into the Swissmic_WMS database in the container

　　　　　　　　　　$ mysql -u root -p Swissmic_WMS < db.sql

　　　　　　　　4. Test data is imported successfully

　　　　　　　　　　$ mysql -u root -p root

　　　　　　　　　　　　>> use Swissmic_WMS;

　　　　　　　　　　　　>> show tables;

　　　　　　　　　　If you see the table you want, congratulations, the data import is successful. Otherwise, it is necessary to check from the first step.

　　　　　　　　　　　　>> exit;

　　　　　　　　5. Exit the container

　　　　　　　　　　$ exit

　　　　　　　　6. Take down the app

　　　　　　　　　　$ docker stack rm SwieApp

　　　　　　　　7. Redeploy run

　　　　　　　　　　$ docker stack deploy -c docker-compose.yml SwieApp

　　　　　　4. Check if three services are started

　　　　　　　　$ docker service ls

　　　　　　　　　　ID NAME MODE REPLICAS IMAGE PORTS

　　　　　　　　　　h83om38jtc7v SwieApp_activemq replicated 1/1 haizeiwang/activemq:v1 *:1884->1884/tcp

　　　　　　　　　　ihz1e4c2c4qk SwieApp_db replicated 1/1 haizeiwang/mysql:v1 *:4000->3306/tcp

　　　　　　　　　　juwgtknfg151 SwieApp_web replicated 1/1 haizeiwang/wanlida_server:v3 *:8080->8080/tcp

　　　　　　5. Look for output for the web service, prepended with your app name.

　　　　　　　　$ docker service ps SwieApp_web

　　　　　　　　　　ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS

　　　　　　　　　　lt8zpktos7dj SwieApp_web.1 haizeiwang/wanlida_server:v1 guojihai-TM1604 Running Running about a minute ago

　　　　　　6. You can run http://localhost:8080/wms in your browser. If successful, you will see the login page.

　　　　The difference between Method 1 and Method 2:After the server is restarted, Method 1 needs to restart the service with the command docker-compose start, but Method 2 will restart automatically.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~end line~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Uninstall Docker CE 　　1.Uninstall the Docker CE package: 　　　　$ sudo apt-get purge docker-ce 　　　　$ sudo apt-get remove --auto-remove docker 　　2.Images, containers, volumes, or customized configuration files on your host are not automatically removed. To delete all images, containers, and volumes: 　　　　$ sudo rm -rf /var/lib/dockerUninstall Docker Compose 　　1.To uninstall Docker Compose if you installed using curl: 　　　　$ sudo rm /usr/local/bin/docker-compose 　　2.To uninstall Docker Compose if you installed using pip: 　　　　$ pip uninstall docker-compose