CentOS7中Docker常用命令、安装镜像（centos7、mysql、nginx、jdk、jar）

1、Docker常用命令

docker命令中的参数：

-i：以交互模式运行容器，通常与 -t 同时使用

-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用

-d：后台运行容器，并返回容器ID

-p：宿主机端口与容器端口映射

-v：宿主机的文件夹挂载到容器系统的目录下，容器运行时生成的数据文件会保存在宿主机上

-e：为项目中使用的环境变量赋值

--net=host：容器启动后与宿主机共享网络，便于访问其他容器在宿主机上的映射端口，例如连接mysql

--name springdata：给容器起一个名字

--restart=always：docker重启时容器也会重启

docker常用命令：

docker操作必须是root账户或者同等权限

# 根据 Dockerfile 构建 Docker 镜像，docker构建镜像时必须使用Dockerfile，Dockerfile名字是固定的
# 最后边的“.”意思是在当前目录寻找Dockerfile
docker build -t meetingfilm-backend:1.0 .

# 下载 Docker 镜像
docker pull 镜像名字[:VERSION]
docker pull tomcat  等价于  docker pull tomcat:latest
docker pull mysql:5.7
docker pull centos:7.7.1908
docker pull java:8u231

# 删除镜像
docker rmi -f 镜像ID
#删除多个
docker rmi -f 镜像1ID:VERSION 镜像2ID:VERSION
# 删除全部
docker rmi -f $(docker images -qa)

# 查看所有的Docker 镜像列表
docker images

# 将 Docker 镜像启动成一个容器
docker run -itd centos:7.7.1908 /bin/bash
docker run -itd -p 8881:8881 meetingfilm-backend:1.0
docker run -p 3309:3306 --name mysqlDocker -v /dockerData/mysql/conf:/etc/mysql/conf.d -v /dockerData/mysql/logs:/logs -v /dockerData/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql-docker:5.7
# 如果启动一个导入的镜像，需要带上导出镜像时的command

#查看已经运行的Docker容器列表
docker ps -a
docker ps -a --no-trunc    # 不省略信息

# 进入容器bash
docker exec -it  bash

# 停止已启动的docker容器
docker stop 
# 启动已存在的docker容器
docker start 
# 重启已启动的docker容器
docker restart 
# 删除容器
docker rm 
#停止并删除容器
docker stop  & docker rm 

# 重启docker服务
# 重启：systemctl restart docker.service
# 停止：systemctl stop docker.service   
# 启动：systemctl start docker.service

# docker 容器存放位置
/var/lib/docker/containers

# 容器间互联（network）
# 创建network
docker network create kafka-network
# 查看network列表：
docker network ls
# 在创建的network上启动Kafka和Zookeeper容器，Kafka容器甚至可以通过network的名字而不是IP连接到Zookeeper：
docker run -d --name zookeeper --network kafka-net zookeeper:3.4
docker run -d --name kafka --network kafka-net -e ZOOKEEPER_IP=zookeeper kafka

2、docker中安装centos7镜像

1、下载镜像

[root@CentOS7-3 /]# docker pull centos:7
# 或者指定精确版本
[root@CentOS7-3 /]# docker pull centos:7.7.1908

2、启动centos7容器，必须指定 command 为 /bin/bash，否则容器启动后会自动停止

# 根据镜像名称启动
[root@CentOS7-3 /]# docker run -itd : /bin/bash
# 根据镜像id启动
[root@CentOS7-3 /]# docker run -itd  /bin/bash

3、查看容器id

[root@CentOS7-3 /]# docker ps -a
CONTAINER ID        IMAGE                     COMMAND                  CREATED             STATUS              PORTS                    NAMES
f46c69ee4d3e        centos:7.7.1908           "/bin/bash"              20 seconds ago      Up 19 seconds                                heuristic_haibt

4、进入容器bash

[root@CentOS7-3 /]# docker exec -it  bash

5、ctrl + d 退出bash

3、安装mysql、启动容器、访问数据库

1、下载mysql镜像

# 下载最新版本
[root@CentOS7-3 /]# docker pull mysql
# 下载指定版本
[root@CentOS7-3 /]# docker pull mysql:5.7
# 查看下载的镜像
[root@CentOS7-3 /]# docker images
# 查看结果如下：
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
docker.io/mysql       5.7                 7c6353462936        2 minutes ago       429 MB
docker.io/centos      7.1.1503            e1430271e2f9        11 months ago       212 MB

2、在docker的宿主机上创建数据文件夹、配置文件文件夹、日志文件夹

# 使用 mkdir -p 可以递归创建目录
[root@CentOS7-3 /]# mkdir -p /dockerData/mysql/conf /dockerData/mysql/data /dockerData/mysql/logs

3、创建并启动mysql容器

# 创建mysql容器，并启动容器
[root@CentOS7-3 /]# docker run -p 3309:3306 --name mysqlDocker -v /dockerData/mysql/conf:/etc/mysql/conf.d -v /dockerData/mysql/logs:/logs -v /dockerData/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
# 启动结果如下：
8d1b288e6fe7d038a64685a340d0385a5c7f14c7a7a1617494fab3c6771302dd
# 查看已经运行的Docker容器列表
docker ps -a
# 查看结果如下：
[root@CentOS7-3 /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
8d1b288e6fe7        mysql:5.7           "docker-entrypoint..."   2 minutes ago       Up About a minute   33060/tcp, 0.0.0.0:3309->3306/tcp   mysqlDocker

# 命令说明：
--name    命名为mysqlDocker
-p 3309:3306    将容器的 3306 端口映射到主机的 3309 端口
-v /dockerData/mysql/conf:/etc/mysql/conf.d    将宿主机/dockerData/mysql/conf 挂载到容器的 /etc/mysql/conf.d 
-v /dockerData/mysql/logs:/logs    将宿主机/dockerData/mysql 挂载到容器的 /logs
-v /dockerData/mysql/data:/var/lib/mysql    将主机/dockerData/mysql/data 挂载到容器的 /var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456    设置 root 用户的密码为123456
-d 后台运行

4、进入容器bash、登录mysql、执行sql语句、退出mysql、退出容器bash

# docker exec -it  bash
[root@CentOS7-3 /]# docker exec -it 8d1b288e6fe7 bash
# 登录mysql
root@8d1b288e6fe7:/# mysql -uroot -p123456
# 登录结果如下：
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 2
Server version: 5.7.29 MySQL Community Server (GPL)

Copyright (c) 2000, 2020, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

# 执行sql语句
mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
| sys                |
+--------------------+
4 rows in set (0.00 sec)

# 退出mysql，使用 quit 或 exit 
mysql> exit
Bye

# 退出容器bash
使用键盘 ctrl + d

5、此时可以使用 Navicat 访问CentOS的3309端口连接 docker容器中的数据库。

6、容器启动后可以编辑容器内部文件

# 将本地文件copy到容器内部
docker cp /shiningcity/test.xml 8d1b288e6fe7:/home/shiningcity/

7、退出docker的mysql容器

[root@CentOS7-3 /]# docker stop 8d1b288e6fe7
# 此时再使用 docker ps -a 查看容器，发现容器状态为退出。

#停止已启动的docker容器
docker stop 
#启动已存在的docker容器
docker start 
#重启已启动的docker容器
docker restart 

4、将容器导出成tar包，将tar包导入成镜像，启动容器

1、查看启动中的容器

# 缩略查看
[root@CentOS7-3 /]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                         PORTS               NAMES
8d1b288e6fe7        mysql:5.7           "docker-entrypoint..."   About an hour ago   Exited (0) About an hour ago                       mysqlDocker

# 全文查看
[root@CentOS7-3 /]# docker ps -a --no-trunc
CONTAINER ID                                                       IMAGE               COMMAND                         CREATED             STATUS                         PORTS               NAMES
8d1b288e6fe7d038a64685a340d0385a5c7f14c7a7a1617494fab3c6771302dd   mysql:5.7           "docker-entrypoint.sh mysqld"   About an hour ago   Exited (0) About an hour ago                       mysqlDocker

2、将容器导出成tar，必须在容器启动时导出。

# 保存到当前文件夹
[root@CentOS7-3 /]# docker export e3cbaa08c34c > mysql-docker.tar
# 保存到指定文件夹
[root@CentOS7-3 /]# docker export e3cbaa08c34c > /文件夹/mysql-docker.tar

3、将保存的tar包，恢复成一个新的镜像（可以将其他机器生成的tar包恢复成镜像）

[root@CentOS7-3 /]# cat mysql-docker.tar |docker import - mysql-docker:5.7

4、恢复的镜像启动成容器时需要带上tar包导出前的command

docker run -p 3309:3306 --name mysqlDocker -v /dockerData/mysql/conf:/etc/mysql/conf.d -v /dockerData/mysql/logs:/logs -v /dockerData/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql-docker:5.7 docker-entrypoint.sh mysqld

5、docker安装nginx镜像

1、下载镜像

[root@CentOS7-3 /]# docker pull nginx

2、下载完成后可以先启动容器，然后进入容器看看配置文件

# 将镜像启动成容器
[root@CentOS7-3 /]# docker run -itd -p 80:80 nginx
# 查看容器列表
[root@CentOS7-3 /]# docker ps -a
CONTAINER ID        IMAGE                     COMMAND                  CREATED             STATUS                        PORTS                               NAMES
938d8d8fb120        nginx                     "nginx -g 'daemon ..."   12 hours ago        Up 7 minutes                                                      nginx
# 进入容器    （exit指令可以退出容器）
[root@CentOS7-3 /]# docker exec -it 938d8d8fb120 bash

# nginx的四个主要目录
# 主配置文件位置：       /etc/nginx/nginx.conf
# 反向代理配置文件位置：  /etc/nginx/conf.d/default.conf
# 默认首页存放位置：      /usr/share/nginx/html/index.html
# 日志存放位置：         /var/log/nginx/access.log

# 正式启动容器时，这些文件要映射到宿主机上，便于更改。

2、创建宿主机文件夹，存放nginx配置文件

mkdir -p /dockerData/nginx/conf
mkdir -p /dockerData/nginx/conf.d
mkdir -p /dockerData/nginx/html
mkdir -p /dockerData/nginx/logs

3、创建主配置文件

[root@CentOS7-3 /]# vi /dockerData/nginx/conf/nginx.conf

# 文件内容如下：
user  root;
worker_processes  1;
error_log /var/log/nginx/error.log;
pid /run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include /etc/nginx/mime.types;
    # 引入反向代理配置文件
    include /etc/nginx/conf.d/*.conf;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;
    sendfile        on;
    keepalive_timeout  65;
}

4、创建反向代理配置文件

[root@CentOS7-3 /]# vi /dockerData/nginx/conf.d/default.conf

# 文件内容如下：
# 代理服务器
upstream shiningserver {
    # 可以通过 172.17.0.1:port 代理宿主机的服务
        server 172.17.0.1:8082;
    # 由于启动容器时将设置容器与宿主机网络共享，所以可以通过 localhost:port 代理宿主机的服务
        #server localhost:8082;
    # 也可以通过宿主机的 host:port 代理宿主机的服务
        #server 192.168.195.130:8082;
}
server {
    # nginx服务器访问端口
    listen       80;
    server_name  localhost;

    location / {
            # 设置允许跨域
            # 允许的请求来源
            add_header Access-Control-Allow-Origin *;
            # 允许的请求方法
            add_header Access-Control-Allow-Methods 'GET,POST,OPTIONS,DELETE,PUT';
            # 允许接收的请求头
            add_header Access-Control-Allow-Headers 'DNT,X-Mx-ReqToken,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Authorization';
            # 预检请求间隔时间，在间隔时间内不需要发送预检请求，单位：秒
            add_header 'Access-Control-Max-Age' 3600;
            #add_header 'Content-Type' 'text/plain; charset=utf-8';
            add_header 'Content-Type' 'application/json; charset=utf-8';
            # 这是预检请求（试探是否允许跨域的请求）
            if ($request_method = 'OPTIONS') {
                return 204;
            }
        # 指向代理服务器，就是上边配置的upstream
        proxy_pass http://shiningserver;
    }

    # 错误提示页面
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   html;
    }
}

5、启动容器，（启动前先将刚才临时启动的容器删除  docker rm ）

docker run -itd --net=host --name nginx -p 80:80 -v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v /dockerData/nginx/conf.d/default.conf:/etc/nginx/conf.d/default.conf -v 
/usr/docker/nginx/html:/usr/share/nginx/html -v /dockerData/nginx/logs:/var/log/nginx nginx

6、测试代理

6、docker安装jdk镜像

[root@CentOS7-3 /]# docker pull java:8
# 默认版本8u111
# 可以使用此镜像为基础生成java项目的镜像。

7、docker生成 SpringBoot导出jar包 的镜像

1、基于java:8镜像生成javaProject镜像：

前提准备：将Dockerfile、项目jar包放到一块，如下：

基于java:8镜像的Dockerfile：

# 指定基础镜像，本地没有会从dockerHub pull下来
FROM java:8
#作者
MAINTAINER ShiningCity
# 把可执行jar包复制到基础镜像的根目录下
ADD backend-eureka-server-0.0.1-SNAPSHOT.jar /shiningcity/backend-eureka/backend-eureka-server.jar
# 镜像要暴露的端口，如要使用端口，在执行docker run命令时使用-p生效
EXPOSE 8881
# 在镜像运行为容器后执行的命令
ENTRYPOINT ["java","-jar","/shiningcity/backend-eureka/backend-eureka-server.jar"]

1、基于centos:7镜像生成javaProject镜像：

前提准备：将jdk tar包、Dockerfile、用到的脚本、项目jar包放到一块，如下：

基于centos:7镜像的Dockerfile：

# 指定基础镜像，本地没有会从dockerHub pull下来
FROM centos7.7.1908

#作者
MAINTAINER ShiningCity
# 设置环境变量
ENV LANG zh_CN.utf-8
# 指定用户
USER root

# 将jdk tar包复制到指定文件夹，并解压
ADD ./jdk-8u231-linux-x64.tar.gz /shiningcity/java8
# 把可执行jar包复制到工作空间目录下
COPY ./eurekaServer/backend-eureka-server-0.0.1-SNAPSHOT.jar /shiningcity/eurekaServer/backend-eureka-server.jar
COPY ./showConsumer/backend-show-consumer-0.0.1-SNAPSHOT.jar /shiningcity/showConsumer/backend-show-consumer.jar
COPY ./showProvider/backend-show-provider-0.0.1-SNAPSHOT.jar /shiningcity/showProvider/backend-show-provider.jar
COPY ./showZuul/backend-show-zuul-0.0.1-SNAPSHOT.jar /shiningcity/showZuul/backend-show-zuul.jar
# 把启动脚本复制到工作空间目录下
COPY ./entrypoint.sh /shiningcity/entrypoint.sh

# 设置环境变量
ENV JAVA_HOME /shiningcity/java8/jdk1.8.0_231
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
# 设置容器默认工作目录
WORKDIR /shiningcity
# 设置环境变量
ENV PATH /shiningcity:$JAVA_HOME/bin:$PATH

# 对启动脚本授权
RUN chmod a+x *.sh
# 暴露端口
EXPOSE 8080

# 在镜像运行为容器后执行的命令
# 启动单个jar包时可以这样写：
# ENTRYPOINT ["java","-jar","/shiningcity/backend-eureka/backend-eureka-server.jar"]
# 启动多个jar包时可以将命令放在一个脚本中执行：
# （指定的目录为相对目录，相对于容器的工作目录，完整目录为：/shiningcity/entrypoint.sh）
ENTRYPOINT ["entrypoint.sh"]

多jar包启动的脚本：entrypoint.sh

#!/bin/sh

cd /shiningcity
nohup java -Dfile.encoding="UTF-8" -jar /shiningcity/eurekaServer/backend-eureka-server.jar &
nohup java -Dfile.encoding="UTF-8" -jar /shiningcity/showConsumer/backend-show-consumer.jar &
nohup java -Dfile.encoding="UTF-8" -jar /shiningcity/showProvider/backend-show-provider.jar &
nohup java -Dfile.encoding="UTF-8" -jar /shiningcity/showZuul/backend-show-zuul.jar &
for (( ; ; ))
do
  sleep 5
done

2、Dockerfile和jar包放在同一文件夹下，构建镜像

注意：导出的jar包要连接docker中mysql容器的数据库，所以数据库连接的配置要与mysql容器对应。

[root@CentOS7-3 /]# docker build -t eurekaServer:1.0 .

3、先启动mysql容器

[root@CentOS7-3 /]# docker run -p 3309:3306 --name mysqlDocker -v /dockerData/mysql/conf:/etc/mysql/conf.d -v /dockerData/mysql/logs:/logs -v /dockerData/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

4、将镜启动成容器，注意容器要使用宿主机的网络，便于连接数据库容器

# 普通启动（前提是项目项目数据库的连接配置使用了mysql镜像的连接参数）
[root@CentOS7-3 /]# docker run -itd --net=host --name eurekaServer-p 8881:8881 eurekaServer:1.0
# --net=host 容器与宿主机共享网络，可以连接同机的mysql容器。
# -p 8881:8881 前边8881是使用宿主机8881端口，后边8881是对应容器中8881端口，这样访问宿主机8881端口就可以访问容器中8881端口的服务。

# 带变量启动（前提是项目数据库的连接配置中使用了变量）
[root@CentOS7-3 /]# docker run -itd --net=host --name eurekaServer --restart=always \
-e MYSQL_HOST=localhost \
-e MYSQL_PORT=3309 \
-e MYSQL_USER=root \
-e MYSQL_PASS=123456 \
-p 8881:8881 eurekaServer:1.0
# --restart=always  docker重启时容器也会重启
# 使用带变量启动的前提是项目数据库的连接配置中使用了变量，如下：
spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:${MYSQL_PORT:3306}/shiningcity?useUnicode=true&characterEncoding=UTF-8&useSSL=true&serverTimezone=UTC
spring.datasource.username=${MYSQL_USER:root}
spring.datasource.password=${MYSQL_PASS:root}
spring.datasource.sqlScriptEncoding=UTF-8
spring.jpa.show-sql=true
# ${MYSQL_HOST:localhost}：如果启动时指定了变量的值，则使用变量值，如果没有指定，则使用localhost

对于带变量启动的指令可以写成一个脚本：startEurekaServer.sh

#!/bin/sh

export MYSQL_HOST=localhost
export MYSQL_PORT=3309
export MYSQL_USER=root
export MYSQL_PASS=123456

export CONTAINER_NAME=eurekaServer
export VERSION=1.0

docker run -itd --name ${CONTAINER_NAME} --net=host --restart=always \
-e MYSQL_HOST=${MYSQL_HOST} \
-e MYSQL_PORT=${MYSQL_PORT} \
-e MYSQL_USER=${MYSQL_USER} \
-e MYSQL_PASS=${MYSQL_PASS} \
-p 8881:8881 ${CONTAINER_NAME}:${VERSION}