Docker之旅

目录

目录

1、使用Docker的好处

2、docker 与 虚拟机的对比

3、docker的安装

4、docker中核心概念 和 核心架构图

5. docker 下载镜像的加速设置

6. docker入门案例

7. docker 引擎和镜像的相关操作

8. 容器的基本操作(一)

9. 容器的基本操作(二)

10. 容器的基本操作(三)

11. docker 镜像分层原理 

12. docker中容器之间网络配置

13. docker中数据卷的详解 

14. docker核心架构图​

15. docker安装MySQL服务

16. docker安装tomcat服务

17. docker安装redis服务

18. docker 安装 ES 服务

19. docker 安装Kibana 并连接到ES

20. Dockerfile  镜像构建文件

---

官方文档地址：https://www.docker.com/get-started

中文参考手册：https://vuepress.mirror.docker-practice.com/

1、使用Docker的好处

1. Docker可以将应用程序以及使用的软件环境打包在一起。无论在哪个机器上都保证了环境一致

2. 对程序进行封装隔离，容器与容器之间互不影响，更高效的利用系统资源

3. 通过镜像复制N个环境一致容器

2、docker 与 虚拟机的对比

3、docker的安装

1. docker 在windows系统安装

        地址：https://www.docker.com/get-started

 2. docker在linux系统安装

        地址：https://www.docker.com/get-started

        curl -fsSL get.docker.com -o get-docker.sh

        sudo sh get-docker.sh --mirror Aliyun

3. 启动docker服务

 systemctl status | stop | start | restart docker.server

4. 检测docker 是否安装成功

         docker info

5. 建立docker组，并使用root用户

        sudo group docker

        sudo group -aG docker $USER

6. 重启docker服务

 systemctl restart docker

4、docker中核心概念 和 核心架构图

 1. 镜像 image     （Java类中的对象）

         定义：一个镜像代表一个软件 如：MySQL镜像，redis镜像，nginx镜像

        特点：只读

 2. 容器 container  （Java里的类）

         定义：基于某个镜像运行一次就是生成一个程序实例   一个程序实例称之为一个容器

        特点：可读可写

  3. 仓库   repository    (相当于GitHub）

        定义：用来存储docker中所有的镜像具体位置

        远程仓库：docker在世界范围维护一个唯一的远程仓库

        本地仓库：当前自己机器中下载镜像存储位置

5. docker 下载镜像的加速设置

 登录阿里云

进入控制台

在容器镜像服务中

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://r6zn5y4k.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
 

使用docker info 查看镜像地址

6. docker入门案例

docker run hello-world

7. docker 引擎和镜像的相关操作

1. 查看docker引擎以及docker帮助命令

        docker info: 用来展示docker信息(版本 等等)

        docker --help   ||  docker  查看docker所有帮助命令

2. 操作镜像images的相关命令 

a. 查看本地仓库的所有镜像

    docker images

REPOSITORY(镜像名称) TAG(镜像版本) IMAGE ID(镜像唯一id) CREATED(镜像的创建时间)  SIZE(镜像大小)
    hello-world           latest          d1165f221234         3 months ago    13.3kB

b.下载新的镜像

    docker pull 镜像名称:版本号
    docker pull mysql:8.0.18
 
c. 搜索需要的镜像

    docker search 镜像名称
    docker search redis

d. 删除镜像
    
    docker image rm  镜像名字:版本号
    docker image rm  镜像id
    docker rmi  镜像id
    docker rmi $(docker images -qa)  删除所有镜像

e. 列出指定镜像

    docker images redis

8. 容器的基本操作(一)

0. 将打包tar镜像文件导入到自己的 docker 仓库

        docker load  -i 导入镜像的tar

1. 通过镜像运行一个容器

        docker run 镜像名:版本号  || 镜像id

        a.

a. 以tomcat镜像为例运行tomcat容器(运行tomcat实例)
    
    docker run tomcat:8.5.68-jdk8-openjdk-slim-buster

b. 宿主机端口与容器中端口进行映射 -p 
    
    docker run -p 8080(宿主机端口):8080(容器内服务监听的端口) tomcat:8.5.68-jdk8-openjdk-slim-buster

c. 启动容器  映射外部端口  后台启动

   docker run -p 8080(宿主机端口):8080(容器内服务监听的端口) -d(后台映射) tomcat:8.5.68-jdk8-openjdk-slim-buster

d.  启动容器 指定名称  后台运行  端口映射
    
    docker run -d(后台运行) -p 8080:8080 --name tomcat01(容器名称) tomcat:8.5.68-jdk8-openjdk-slim-buster  

2. 查看当前运行的容器

        docker ps  查看正在运行的容器

        docker ps -a   查看所有容器(运行 & 非运行)

        docker ps -q  返回正在运行的容器id

3. 停止  重启容器的命令 

        docker  stop | start  | restart 容器id

9. 容器的基本操作(二)

1. 删除容器

        docker rm 容器id | 容器名称

        docker rm -f 容器id | 容器名称

        docker rm -f $(docker ps -aq)  删除所有容器

2. 查看容器内部服务运行日志

        docker logs 容器id | 容器名称    查看一下

        docker logs -f 容器id | 容器名称    实时展示日志

        docker logs -tf 容器id | 容器名称   实时展示日志+时间戳

        docker logs --tail n 容器id | 容器名称   只显示某容器尾部的n行日志

3. 查看容器内的进程

        docker top 容器id  | 容器名称 

4. 与容器内部进行交互   每个容器相当于小型的linux系统

        docker exec -it 容器id或者容器名 bash    (bash  ，容器内部的命令行)

        退出容器：exit

5. 操作系统与容器的传输文件

       a.  从容器复制文件到操作系统:  docker cp 容器id | 容器名称 ：容器内的资源路径  操作系统中的路径

      docker cp tomcat01:/usr/local/tomcat/RUNNING.txt /

       b.  从操作系统复制文件到容器内部 : docker cp 文件名称 容器id | 容器名称 : 容器内的资源路径 

        docker cp aa.txt tomcat01:/usr/local/tomcat

10. 容器的基本操作(三)

1. 查看容器内部细节

        docker inspect 容器id | 容器名称

2. 数据卷   Volume

        作用：实现宿主机系统与容器之间的文件共享 

数据卷的使用：
    
  a. docker run -d -p 8080:8080 --name tomcat01 -v 宿主机目录:容器内目录  tomcat:8.0
    
    自定义数据卷目录
  docker run -d -p 8081:8080 --name tomcat02 -v /root/apps/:/usr/local/tomcat/webapps tomcat:8.5.68-jdk8-openjdk-slim-buster
    
    自动数据卷目录
  docker run -d -p 8082:8080 --name tomcat03 -v aa:/usr/local/tomcat/webapps tomcat:8.5.68-jdk8-openjdk-slim-buster
    
    注意：
        1. aa代表一个数据卷名字，可以随便写，docker会在不存在aa时自动创建这个数据卷，同时自动                
           映射宿主机中某个目录、
        2. 同时在启动容器时会将aa对应容器目录中全部内容复制到aa映射目录中

[root@localhost /]# find / -name aa  找这个aa在哪

3. 将容器打包成一个新的镜像

docker commit -m "描述信息" -a "作者信息" (容器id或者容器名称) 打包的镜像名称:版本

4. 将镜像备份出来     

  docker save 镜像名称:镜像版本 -o 文件名

  docker save mxd-tomcat:1.0 -o mxd-tomcat-1.0.tar    

11. docker 镜像分层原理 

0. 镜像

        定义：一个镜像代表一个软件  软件包   用来打包软件运行环境和基于运行环境开发的软件，它包含某个软件所需的所有内容，包括代码、运行时间所需的库、环境变量和配置文件

1. 镜像为什么这么大？

        原因：一个软件镜像不仅仅是原来的软件包，包含软件包所需的操作系统依赖，软件自身依赖 以及 自身软件包 组成

2. 为什么docker镜像采用分层原理

                好处： 资源共享，资源复用，采用分层机制实现基础层共享，从而减少docker仓库整体体积，将公告镜像拆分出来

        注意：docker在设计镜像时每一个镜像都是由 n 个镜像组成

        原理：

                UnionFS 联合文件系统

12. docker中容器之间网络配置

0. 为什么提供网络功能

        docker 允许通过外部访问容器或容器互联的方式来提供网络服务

1. docker容器与操作系统通信机制

2. docker 网络使用

        注意：一般在使用docker网桥(bridge)实现容器与容器通信时，都是站在一个应用角度进行容器通信

a. 查看docker容器默认网桥配置
    docker network ls

b. 创建自定义网桥
    docker netword create ems(网桥名称)  ==>  docker network create -d bridge ems(网桥名称)
 
启动容器时指定网桥 docker run -d -p 8080:8080 --name tomcat01 --network ems(网桥名称) tomcat:8.0
    指定网桥后，会将容器name和网桥分配的ip地址进行映射，即 tomcat01 <-> ip

c. 删除网桥
    docker network rm ems(网桥名称)

d. 查看网桥信息
    docker inspect ems(网桥名称)
注意：使用docker run 指定 --network网桥时，网桥必须存在

13. docker中数据卷的详解 

1. 数据卷的作用

        用来实现容器和宿主机之间数据共享

2. 数据卷的特点       

a. 数据卷可以在容器之间共享和重用

b. 对数据卷的修改会立即影响到对应容器

    docker run -d -p 8085:8080 --name tomcat05 -v /apps/:/usr/local/tomcat/webapps:ro tomcat:8.5.68-jdk8-openjdk-slim-buster   

        加 ro ，代表是readonly 容器内的目录只读

c. 对数据卷的 更新修改，不会影响到镜像

d. 数据卷默认会一直存在，即使容器被删除

3. 数据卷的操作

a. 自定义数据卷目录
    docker run -v 绝对路径:容器内的路径

b. 自动创建数据卷
    docker run -v 卷名(随便起):容器内路径

4. docker 操作数据卷的指令

a. 查看数据卷
    docker volume ls

b. 查看某个数据卷的细节
    docker volume inspect 卷名

c. 创建数据卷
    docker volume create 卷名

d. 删除没有使用的数据卷
    docker volume prune

e. 删除指定的数据卷
    docker volume rm 卷名

14. docker核心架构图

15. docker安装MySQL服务

1. 先去docker hub 上搜索镜像

2.  docker pull mysql:8.0.18

3. 如何使用镜像

a. 基本启动MySQL服务
    docker run -e MYSQL_ROOT_PASSWORD=root mysql:8.0.18
    -e MYSQL_ROOT_PASSWORD=root  代表给root用户指定密码

b. 启动后一个mysql服务  后台运行  指定root用户密码，指定容器名字
    docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root --name mysql mysql:8.0.18

c. 启动一个mysql服务 后台运行  指定root用户密码，指定容器名字  使用数据卷将容器中数据持久化到宿主机系统，指定名字
    注意：通过docker hub描述得知，mysql存储数据文件目录放置在容器的 /var/lib/mysql 目录
    
    docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -v mysqldata:/var/lib/mysql --name mysql mysql:8.0.18

d. 启动一个MySQL服务， 后台运行，指定root用户密码 指定容器名字 使用数据卷将容器中数据持久化到宿主机系统  以修改之后的配置文件启动

    docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root -v mysqldata:/var/lib/mysql -v mysqlconfig:/etc/mysql --name mysql mysql:8.0.18

16. docker安装tomcat服务

1. 下载tomcat镜像

        docker pull tomcat:8.0-jre8

2. 启动tomcat服务       

 a. 将部署应用目录通过数据卷挂载到宿主机系统
        
    注意：部署web应用在容器中目录为 /usr/local/tomcat/webapps
           配置文件在容器中目录为 /usr/local/tomcat/conf
    docker run -d -p 8080:8080 --name tomcat -v /apps:/usr/local/tomcat/webapps tomcat:8.0-jre8

b. 修改配置文件，并将应用目录通过数据卷挂载到宿主机系统
    
    docker run -d -p 8080:8080 --name tomcat -v /apps:/usr/local/tomcat/webapps -v 
confs:/usr/local/tomcat/conf tomcat:8.0-jre8

17. docker安装redis服务

1. 下载redis镜像

        docker pull redis:5.0.12

2. 启动redis

        docker run -d -p 6379:6379 --name redis redis:5.0.12

3. 开启redis持久化

        docker run --name redis01 -p 6379:6379 -d -v redisdata:/data redis:5.0.12 redis-server --appendonly yes

        注意：一旦开启持久化之后，持久化生成aof文件会被放入容器中 /data 目录中

4. 修改redis配置文件，以配置文件方式启动

        注意：需要去找一份redis的配置文件redis.conf

        docker run -d -p 6379:6379 -v /redisconf:/usr/local/etc/redis --name redis redis:5.0.12 redis-server /usr/local/etc/redis/redis.conf

18. docker 安装 ES 服务

1. 下载镜像

        docker pull elasticsearch:6.8.0

2. 运行镜像

        指定名字、网桥、端口、单机启动、后台启动

       docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:6.8.0

         docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 elasticsearch:6.8.0

  启动如果会报错, 虚拟内存太小

        解决方案：

1.修改配置 sysctl.conf
    vim /etc/sysctl.conf
2.加入以下配置
    vm.max_map_count=262144
3.启用配置
    sysctl -p

3. 访问es的web界面

         39.107.67.58:9200

4. ES 中持久化方案

        注意：ES中所有数据都在容器中 /usr/share/elasticsearch/data

                所有的配置信息都在容器中 /usr/share/elasticsearch/config

                所有的插件信息都在容器中  /usr/share/elasticsearch/plugins

    docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -v esdata:/usr/share/elasticsearch/data -v esconfig:/usr/share/elasticsearch/config elasticsearch:6.8.0

5. ES 持久化 改配置 安装ik分词器

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -v esdata:/usr/share/elasticsearch/data -v esconfig:/usr/share/elasticsearch/config -v esplugins:/usr/share/elasticsearch/plugins elasticsearch:6.8.0

19. docker 安装Kibana 并连接到ES

1. 下载Kibana镜像

        docker pull kibana:6.8.0

2. 运行Kibana，最好和elasticsearch在一个网桥

        docker run -d --name kibana --net somenetwork -p 5601:5601 kibana:6.8.0

a. 简单的启动一个kibana服务，没有连接ES
    docker run -d --name kibana -p 5601:5601 kibana:6.8.0

b. 启动kibana服务，并连接到ES
    docker run -d --name kibana -p 5601:5601 -e ELASTICSEARCH_URL=http://172.17.0.2:9200 kibana:6.8.0

20. Dockerfile  镜像构建文件

1. 什么是Dockerfile

        定义：用来帮助我们自己构建一个自定义镜像   Dockerfile成为镜像构建文件    描述文件

2. 为什么要存在Dockerfile

        核心作用：用户可以将自己应用打包成镜像，这样就可以让我们应用在容器中运行

3. Dockerfile 构建镜像的原理

4. Dockerfile 使用

Dockerfile的保留命令

FROM      当前镜像是基于哪个镜像
RUN       构建镜像时需要运行的指令
EXPOSE    当前容器对外暴露的端口号
WORKDIR   指定在创建容器后，终端默认登陆进来的工作目录，一个落脚点
ENV       用来在构建镜像过程中设置环境变量
ADD       将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar包
COPY      类似于ADD，拷贝文件和目录到镜像中

    ADD 可以写URL进行下载一下东西，COPY不可以

VLOUME    容器数据卷，用于数据保存和持久化工作
CMD       指定一个容器启动时要运行的命令
ENTRYPOINT  指定一个容器启动时要运行的命令

5. 构建镜像

docker build -t mycentos7:02 .

21. Dockerfile 构建SpringBoot应用

1.开发一个完整的SpringBoot应用程序

2.对SpringBoot应用程序进行打包

        jar包  ====> jdk

3. 在服务器中创建Dockerfile上下文目录  context

a. mkdir deom   这个目录为context目录
b. 在demo目录中创建Dockerfile文件   vim Dockerfile
c. 上传应用spring-boot-test-1.0.0.jar包 到 demo 目录
d. 编写Dockerfile

FROM openjdk:8-jdk    # 基于openjdk镜像进行构建
WORKDIR /app          # 定义进入容器时默认位置，接下来后续操作工作位置
ADD spring-boot-test-1.0.0.jar app.jar     # 将上下文中名字为 spring-boot-test-1.0.0.jar 复制            
                                             到工作目录，并修改名字为 app.jar
EXPOSE 8080           # 让当前容器暴露哪个端口  因为项目启动使用端口是8080
ENTRYPOINT ["java","-jar"]    # 启动应用固定名称
CMD ["app.jar"]               # 执行jar的名字


e. 执行构建   docker build -t springboot:01 .

f. 运行容器   docker run -d -p 8080:8080 --name springboot01 springboot:01

22. docker compose使用

1. 什么是 docker compose

        compose项目，负责对 Docker 容器集群的快速编排

2. compose 定位

        定义和运行多个 Docker 容器的应用，同时可以对多个容器进行编排，使多个容器具有顺序的运行

3. compose 核心概念

        服务：一个应用的容器，(实际上可以包括若干运行相同镜像的容器实例),服务可以有多个

        项目：有一组关联的应用容器组成一个完整业务单元，在 'docker-compose.yml ' 文件中定义

4. compose 使用

a.下载 docker-compose
    sudo curl -L https://github.com/docker/compose/releases/download/1.25.5/docker-compose-'uname -s'-'uname -m' > /usr/local/bin/docker-compose
    sudo chmod +x /usr/local/bin/docker-compose

5. 检查 compose 是否安装成功

        docker-compose -v 

21. docker-compose 入门

1.两个重要概念

        项目(project): 有多个服务共同组成一个完整业务单元   定义docker-compose.yml文件中

        服务(service):一个服务对应一个应用容器     在一个项目中可以存在多个服务

2. 第一个docker-compose程序

a.创建一个docker-compose.yml文件
b.在配置文件中定义一个项目存在哪些服务

version: "3.0"
services:
  tomcat01: # 服务名唯一
    image: tomcat:8.0-jre8 # 创建当前这个服务使用镜像是哪个
    ports:
     - 8080:8080

  tomcat02: # 服务名唯一
    image: tomcat:8.0-jre8 # 创建当前这个服务使用镜像是哪个
    ports:
     - 8081:8080

c. 运行docker-compose
    docker-compose up  启动这个项目的所有服务，必须保证运行命令的目录存在docker-compose.yml

22.  docker-compose 命令模板

1.两个重要概念

        项目(project): 有多个服务共同组成一个完整业务单元   定义docker-compose.yml文件中

        服务(service):一个服务对应一个应用容器     在一个项目中可以存在多个服务

2. docker-compose 命令

version: "3.2"

services:
  tomcat01: # 服务名字
    container_name: tomcat01  # 容器名字  代替的是 --name
    image: tomcat:8.0-jre8   # 使用哪个镜像
    ports:  # 用来完成 host 与 容器的端口映射关系
      - "8080:8080"
    volumes:
      - tomcatwebapps01:/usr/local/tomcat/webapps
      #- /apps:/usr/local/tomcat/webapps   # 使用自定义路径映射
  networks:  # 代表当前服务使用哪个网桥
      - hello

  tomcat02: # 服务名字
    container_name: tomcat02  # 容器名字  代替的是 --name
    image: tomcat:8.0-jre8   # 使用哪个镜像
    ports:  # 用来完成 host 与 容器的端口映射关系
      - "8081:8080"
    volumes:
      - tomcatwebapps02:/usr/local/tomcat/webapps
      #- /apps:/usr/local/tomcat/webapps   # 使用自定义路径映射
  networks:  # 代表当前服务使用哪个网桥
      - hello
      
volumes:    # 声明上面服务所使用的自动创建的卷名
  tomcatwebapps01: # 声明指定的卷名  compose自动创建该卷名
    external:    # 使用自定义卷名
      false      # true确定使用指定卷名
  tomcatwebapps02: # 声明指定的卷名
    external:
      false
 
注意：一旦使用外部自定义卷名启动服务之前必须手动创建卷名
        docker volume create tomcatwebapps

networks:   # 定义服务用到的网桥
  hello:   # 定义上面的服务用到的网桥名称，默认创建的就是 bridge

        bug:在挂载目录时，只允许有一个容器挂载/apps，不知道为什么。

version: "3.2"

services:
  tomcat01: # 服务名字
    container_name: tomcat01  # 容器名字  代替的是 --name
    image: tomcat:8.0-jre8   # 使用哪个镜像
    ports:  # 用来完成 host 与 容器的端口映射关系
      - "8080:8080"
    volumes:
      - tomcatwebapps01:/usr/local/tomcat/webapps
      #- /apps:/usr/local/tomcat/webapps   # 使用自定义路径映射
    networks:   # 代表当前服务使用哪个网桥
      - hello

  tomcat02: # 服务名字
    container_name: tomcat02  # 容器名字  代替的是 --name
    image: tomcat:8.0-jre8   # 使用哪个镜像
    ports:  # 用来完成 host 与 容器的端口映射关系
      - "8081:8080"
    volumes:
      - tomcatwebapps02:/usr/local/tomcat/webapps
      #- /apps:/usr/local/tomcat/webapps  # 使用自定义路径映射
    networks:  # 代表当前服务使用哪个网桥
      - hello

  mysql:
    container_name: mysql
    image: mysql:8.0.18
    ports:
      - "3306:3306"
    volumes:
      - mysqldata:/var/lib/mysql
      - mysqlconf:/etc/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=root
    networks:
      - hello
  
  redis:
    container_name: redis
    image: reids:5.0.10
    ports:
      - "6379:6379"
    volumes:
      - redisdata:/data
    command: "redis-server --appendonly yes"  # run 镜像之后，覆盖容器内默认命令
    networks:
      - hello

volumes:    # 声明上面服务所使用的自动创建的卷名
  tomcatwebapps01: # 声明指定的卷名
    external:
      false
  tomcatwebapps02: # 声明指定的卷名
    external:
      false
  mysqldata:
  mysqlconf:
  redisdata:

networks:   # 定义服务用到的网桥
  hello:   # 定义上面的服务用到的网桥名称，默认创建的就是 bridge