SpringCloud微服务-Docker基本操作

Docker基本操作

文章目录

• Docker基本操作
• • 1、镜像操作命令
  • • 1.1、从DockerHub中拉取一个镜像并且查看
    • 1.2、镜像的导出和导入
    • 2、容器相关命令
    • • 2.1、创建运行一个Nginx容器
      • 2.2、进入容器，并且修改容器中的文件
      • 3、数据卷
      • • 3.1、操作数据卷命令
        • 3.2、案例实战-创建数据卷
        • 3.3、挂载数据卷-创建启动Nginx容器，将宿主机数据卷挂载到容器
        • 3.4、挂载目录-创建并运行MySQL容器，将宿主机目录挂载到容器
        • 4、Dockerfile自定义镜像
        • • 4.1、镜像结构
          • 4.2、Dockerfile语法
          • 4.3、使用Dockerfile构建镜像，运行项目
          • • 案例一：基于Ubuntu镜像构建一个新镜像，运行一个java项目
            • ���例二：基于java:8-alpine镜像，将一个Java项目构建为镜像

              1、镜像操作命令

              • 镜像名称一般分两部分组成：[repository]:[tag]。

              • 在没有指定tag时，默认是latest，代表最新版本的镜像。

                Docker命令图解：

                1.1、从DockerHub中拉取一个镜像并且查看

                1. 首先去镜像仓库搜索nginx镜像，比如DockerHub:
                1. 根据查看到的镜像名称，拉取自己需要的镜像，通过命令：docker pull nginx
                1. 通过命令：docker images 查看拉取到的镜像

                1.2、镜像的导出和导入

                1. 利用docker xx --help命令查看docker save和docker load的语法

                   命令：docker save -o nginx.tar nginx:latest

                   之后就可以使用ll命令查看当前目录下生成名为nginx.tar的文件

                2. 使用docker tag创建新镜像mynginx1.0

                3. 使用docker save导出镜像到磁盘

                常见的命令：

                • docker images：显示本地主机上的所有Docker镜像列表。

                • docker rmi：删除一个或多个本地主机上的Docker镜像。

                • docker pull：从Docker仓库中拉取一个Docker镜像到本地主机。

                • docker push：将本地主机上的Docker镜像推送到Docker仓库。

                • docker save：将一个或多个Docker镜像保存为一个tar归档文件。

                • docker load：从一个tar归档文件中加载一个或多个Docker镜像。

                  真正开发的时候可以借助 --help命令来具体查看和学习各种命令的用法

                  2、容器相关命令

                  当在Linux中使用Docker时，以下是一些常用的Docker容器基本操作命令：

                  1. docker run：创建并启动一个新的容器。
                  2. docker start：启动一个已经存在的容器。
                  3. docker stop：停止一个运行中的容器。
                  4. docker restart：重启一个容器。
                  5. docker pause：暂停一个容器的所有进程。
                  6. docker unpause：恢复一个暂停的容器。
                  7. docker rm：删除一个或多个容器。
                  8. docker ps：列出当前正在运行的容器。
                  9. docker ps -a：列出所有容器，包括停止的容器。
                  10. docker exec：在运行中的容器中执行命令。
                  11. docker logs：查看容器的日志输出。
                  12. docker inspect：查看容器的详细信息。
                  13. docker attach：附加到一个正在运行的容器中。
                  14. docker cp：在容器和主机之间复制文件或目录。
                  15. docker rename：重命名一个容器。

                  常见命令图解：

                  2.1、创建运行一个Nginx容器

                  去docker hub查看Nginx的容器运行命令

                  docker run --name some-nginx -d -p 8080:80 some-content-nginx

                  命令解读：

                  • docker run ：创建并运行一个容器
                  • –name : 给容器起一个名字，比如叫做mn
                  • -p ：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
                  • -d：后台运行容器
                  • nginx：镜像名称，例如nginx

                    真实创建并运行：

                    docker run --name mn  -p 8080:80  -d nginx

                    2.2、进入容器，并且修改容器中的文件

                    以nginx为例：

                    1. 进入容器。进入我们刚刚创建的nginx容器的命令为：

                       docker exec -it mn bash 

                       命令解读：

                       • docker exec ：进入容器内部，执行一个命令（但是不推荐在容器里面修改文件）

                         • -it : 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互

                         • mn ：要进入的容器的名称

                         • bash：进入容器后执行的命令，bash是一个linux终端交互命令

                         • 进入nginx的HTML所在目录 /usr/share/nginx/html

                            cd /usr/share/nginx/html

                         • 修改index.html的内容（不能直接使用vi命令，因为镜像封装是只是封装了镜像必备的函数，而vi刚好没有封装）

                           sed -i 's#Welcome to nginx#你好，Docker容器中的Nginx !#g' index.html sed -i 's###g' index.html

                           实质上只是对文件的内容进行替换。运行结果：

                         • 可以使用exit命令来退出容器。

                    3、数据卷

                    问：数据卷解决了什么问题？

                    1. 不便于修改：当我们要修改Nginx的html内容时，需要进入容器内部修改，很不方便。
                    2. 数据不可复用：在容器内的修改对外是不可见的。所有修改对新创建的容器是不可复用的。
                    3. 升级维护困难：数据在容器内，如果要升级容器必然删除旧容器，所有数据都跟着删除了

                    答：容器与数据耦合的问题。

                    数据卷（volume）是一个虚拟目录，指向宿主机文件系统中的某个目录。将容器与数据分离，解耦合，方便操作容器内数据，保证数据安全.

                    3.1、操作数据卷命令

                    数据卷操作的基本语法如下：

                    语法：docker volume [COMMAND]

                    docker volume命令是数据卷操作，根据命令后跟随的command来确定下一步的操作：（查看帮助文档）

                    语法表格：

                    命令	解释
                    create	创建一个volume
                    inspect	显示一个或多个volume的信息
                    ls	列出所有的volume
                    prune	删除未使用的volume
                    rm	删除一个或多个指定的volume

                    3.2、案例实战-创建数据卷

                    1. 创建数据卷

                    docker volume create html

                    1. 查看所有数据

                    docker volume ls

                    1. 查看数据卷详细信息卷

                    docker volume inspect html

                    3.3、挂载数据卷-创建启动Nginx容器，将宿主机数据卷挂载到容器

                    我们在创建容器时，可以通过 -v 参数来挂载一个数据卷到某个容器目录。

                    docker run   --name mn   -v html:/usr/share/nginx/html  -p 8080:80  -d nginx 

                    解释：

                    • docker run ：就是创建并运行容器

                    • – name mn ：给容器起个名字叫mn

                    • -v html:/root/htm ：把html数据卷挂载到容器内的/root/html这个目录中

                    • -p 8080:80 ：把宿主机的8080端口映射到容器内的80端口

                    • nginx ：镜像名称

                    • -d ：表示后台运行

                      这样，我们就可以在挂载点的目录下找到我们访问Nginx首页的Index.html文件了，就可以使用vi编辑器或其他外部编辑器进行修改。

                      挂载并且启动容器再到访问全流程：（Nginx为例）

                      1. 首先，需要创建html的数据卷（在3.2中已经实现）；

                      2. 使用-v命令添加在创建并且启动Docker容器的命令中（3.3中实现）；

                      3. 使用docker inspect html 查看数据卷的信息：

                      4. 进入到挂载点进行修改里面的index.html内容；

                      5. 在浏览器访问：

                      3.4、挂载目录-创建并运行MySQL容器，将宿主机目录挂载到容器

                      提示：目录挂载与数据卷挂载的语法是类似的：

                      • -v [宿主机目录]:[容器内目录]

                      • -v [宿主机文件]:[容器内文件]

                        1. 在DockerHub中查找命令如下：

                           docker pull mysql

                        2. 创建目录/tmp/mysql/data

                        3. 创建目录/tmp/mysql/conf，将配置文件hmy.cnf文件上传到/tmp/mysql/conf

                           #配置文件内容（就是常见的配置，不用太在意，主要是测试）[mysqld]skip-name-resolvecharacter_set_server=utf8datadir=/var/lib/mysqlserver-id=1000

                        4. 去DockerHub查阅资料，创建并运行MySQL容器，要求：

                           1. 挂载/tmp/mysql/data到mysql容器内数据存储目录

                           2. 挂载/tmp/mysql/conf/hmy.cnf到mysql容器的配置文件

                           3. 设置MySQL密码

                              “以下命令从DockerHub官网上查询得到”

                           docker run \   --name mysql # 容器的名称 -e MYSQL_ROOT_PASSWORD=toor \ #设置数据库密码 -p 3306:3306 \ #数据库端口映射  -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \ # 配置文件的挂载 -v /tmp/mysql/data:/var/lib/mysql \  #数据（目录）文件挂载，记录所以Mysql的数据 -d \ # 后台启动 mysql:latest \

                        5. 连接测试：

                        4、Dockerfile自定义镜像

                        4.1、镜像结构

                        • 镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。

                          镜像是分层结构，每一层称为一个Layer

                          • 基础镜像（BaseImage层）：包含基本的系统函数库、环境变量、文件系统

                          • Entrypoint：入口，是镜像中应用启动的命令

                          • 其它（ Layer 层）：在BaseImage基础上添加依赖、安装程序、完成整个应用的安装和配置

                            4.2、Dockerfile语法

                            什么是Dockerfile？

                            Dockerfile就是一个文本文件，其中包含一个个的指令(Instruction)，用指令来说明要执行什么操作来构建镜像。每一个指令都会形成一层Layer。

                            指令	说明	示例
                            FROM	指定基础镜像	FROM centos:6
                            ENV	设置环境变量，可在后面指令使用	ENV key value
                            COPY	拷贝本地文件到镜像的指定目录	COPY ./mysql-5.7.rpm /tmp
                            RUN	执行Linux的shell命令，一般是安装过程的命令	RUN yum install gcc
                            EXPOSE	指定容器运行时监听的端口，是给镜像使用者看的	EXPOSE 8080
                            ENTRYPOINT	镜像中应用的启动命令，容器运行时调用	ENTRYPOINT java -jar xx.jar

                            更新详细语法说明，请参考官网文档： https://docs.docker.com/engine/reference/builder

                            4.3、使用Dockerfile构建镜像，运行项目

                            案例一：基于Ubuntu镜像构建一个新镜像，运行一个java项目

                            测试资料：百度网盘自取

                            步骤1：新建一个空文件夹docker-demo

                            步骤2：拷贝课前资料中的docker-demo.jar文件到docker-demo这个目录

                            步骤3：拷贝课前资料中的jdk8.tar.gz文件到docker-demo这个目录

                            步骤4：拷贝课前资料提供的Dockerfile到docker-demo这个目录

                            Dockerfile内容：

                            # 指定基础镜像FROM ubuntu:16.04# 配置环境变量，JDK的安装目录ENV JAVA_DIR=/usr/local# 拷贝jdk和java项目的包COPY ./jdk8.tar.gz $JAVA_DIR/COPY ./docker-demo.jar /tmp/app.jar# 安装JDKRUN cd $JAVA_DIR \ && tar -xf ./jdk8.tar.gz \ && mv ./jdk1.8.0_144 ./java8# 配置环境变量ENV JAVA_HOME=$JAVA_DIR/java8ENV PATH=$PATH:$JAVA_HOME/bin# 暴露端口EXPOSE 8090# 入口，java项目的启动命令ENTRYPOINT java -jar /tmp/app.jar

                            步骤5：进入docker-demo

                            步骤6：运行命令：

                            docker build -t javaweb:1.0 .# build ：构建# -t ：tag ，后面接：[镜像名]:[版本(tag)]# . :DockerFile 所在的目录

                            步骤七：启动镜像

                            docker run --name web -p 8090:8090 -d javaweb:1.0

                            步骤八：最后访问 http://192.168.12.131:8090/hello/count，其中的ip改成你的虚拟机ip

                            说明项目成功构建，并且成功将镜像部署在Docker容器下。

                            项目缺点：例如本例中，如果需要创建多个java项目的镜像，但是配置的Dockerfile文件中的操作，安装JDK等环境变量的配置是不必要的，就会导致代码和操作的冗余，当然解决方法如下一个案例所示。

                            案例二：基于java:8-alpine镜像，将一个Java项目构建为镜像

                            实现思路如下：

                            1. 新建一个空的目录，然后在目录中新建一个文件，命名为Dockerfile

                            2. 拷贝课前资料提供的docker-demo.jar到这个目录中

                            3. 编写Dockerfile文件：

                               • 基于java:8-alpine作为基础镜像

                               • 将app.jar拷贝到镜像中

                               • 暴露端口

                               • 编写入口ENTRYPOINT

                                 # 指定基础镜像FROM java:8-alpine# 如果报错，将上面的java:8改成openjdk:8# 暴露端口EXPOSE 8090# 入口，java项目的启动命令ENTRYPOINT java -jar /tmp/app.jar

                               • 使用docker build命令构建镜像

                                 docker build -t javaweb:2.0 .

                               • 使用docker run创建容器并运行

                                 docker run --name web -p 8090:8090 -d javaweb:2.0