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/docker
Uninstall 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
