1.安装docker

1. 安装软件依赖添加软件源

   #安装必要的一些系统工具
   sudo yum install -y yum-utils device-mapper-persistent-data lvm2
   #添加软件源信息
   sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
   #更新并安装Docker-CE
   sudo yum makecache fast
   sudo yum -y install docker-ce
   #开启Docker服务
   sudo service docker start

2. 配置镜像加速：

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

   2. docker指令

   docker服务相关指令

3. 启动,停止,重启,重载服务

   #启动服务
   systemctl start docker
   #停止服务
   systemctl stop docker
   #重启服务
   systemctl restart docker
   #重载服务
   systemctl daemon-reload

   docker镜像相关指令

4. 查看本地镜像 ```bash docker images REPOSITORY TAG IMAGE ID CREATED SIZE

   镜像名称 #版本 #镜像ID #创建时间 #大小

   httpd latest b2c2ab6dcf2e 7 days ago 166MB

docker images -q #只查看镜像ID

docker images http #只查看http镜像

2. 搜索镜像
```bash
docker search redis        #搜索镜像
NAME                 DESCRIPTION                                     STARS        OFFICIAL            AUTOMATED
#镜像名称                #描述信息                                    #喜欢点赞数量        #官方的                #自动构建
redis                Redis is an open source key-value store that…   8096         [OK]                
bitnami/redis        Bitnami Redis Docker Image                      143                               [OK]

1. 下载镜像到本地 ```bash docker pull nginx #将nginx镜像拉去到本地 Using default tag: latest #不加版本号，默认使用官方最新的

下载指定版本nginx，需要去官方网站查找指定版本

docker pull nginx：1.18.0

4. 删除镜像
```bash
#使用image的ID删除
docker rmi 602e111c06b6        #rm表示删除，i表示image。后面跟上image的ID
Untagged: nginx:latest
#使用image的版本号删除
docker rmi nginx:1.17.0
#删除所有的image
docker rmi $(docker images -q) -f    #将所有ID都传递给rmi，-f表示强制删除

docker容器相关指令

1. 创建容器 ```bash 语法：docker run [OPTIONS] IMAGE [COMMAND] [ARG…] OPTIONES： -d:后台运行容器(daemon) -i:以交互模式运行容器,退出后容器自动关闭(terminal interface) -t:为容器添加一个伪终端(terminal),与i一起使用 -p: 指定端口映射，格式为：主机端口:容器端口(port) —volume , -v: 绑定一个卷

example: docker run -it —name ‘centos7.1’ centos /bin/bash #创建容器并进入交互式终端 docker run -id —name ‘centos7.2’ centos #后台运行容器

2. 查看
```bash
语法：docker ps [OPTIONS]
  OPTIONS：
    -a:查看所有容器
       -q:只显示容器id
    -s:显示总的文件大小
    -n:列出最近创建的n个容器
example：
    docker ps -n 1
    CONTAINER ID    IMAGE        COMMAND          CREATED            STATUS            PORTS             NAMES
    #容器ID          #镜像名称        #运行容器需要的指令    
    4e8142ceae7b    centos       "/bin/bash"      4 minutes ago      Up 4 minutes                        centos7.7

1. 启动停止容器

   docker stop centos7.1
   docker start centos7.1
   docker restart centos7.1

2. 删除容器 ```bash docker rm [OPTIONS] CONTAINER [CONTAINER…] OPTIONES: -f :通过 SIGKILL 信号强制删除一个运行中的容器。 -l :移除容器间的网络连接，而非容器本身。 -v :删除与容器关联的卷。

example: docker rm centos7.1

5. 对运行的容器执行指令
```bash
docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
  OPTIONES:
      -d :分离模式: 在后台运行
    -i :即使没有附加也保持STDIN 打开
    -t :分配一个伪终端

3.docker数据卷

1. 数据卷概念

1. 数据卷
   • 数据卷是宿主机的一个目录或文件
   • 当容器目录与数据卷目录绑定后，一方的修改会立即同步到另一方
   • 一个数据卷可以被多个容器同时挂载
   • 一个容器也可以挂载多个数据

2. 数据卷作用

   • 容器数据持久化
   • 外部机器与容器通信
   • 容器之间数据交换

     2.配置数据卷

3. 创建容器时，使用-v参数设置数据卷 ```shell 语法: docker run -v 宿主机PAHT:容器PATH

docker run -id -v /docker/c1/date/:/date —name ‘c1’ centos:7 #将本地目录与容器目录关联

example：

#1. 在本机上创建文件，能映射到docker
[root@docker date]# echo "hello world" > /docker/c1/date/a.txt
[root@1935004b1a5f ~]# cat /date/a.txt 
hello world
#2. 将docker删除，文件依然存在
[root@docker date]# docker rm c1 -f
[root@docker date]# cat a.txt 
hello world

注意：

#1.关联目录必须使用绝对路径
#2.可以挂在多个数据卷
#3.可以挂在多个数据卷

2. 将一个数据卷挂载到两个容器,实现两个容器数据交换
```shell
[root@docker ~]# docker run -id -v /docker/c1/date/:/date --name 'c1' centos:7
[root@docker ~]# docker run -id -v /docker/c2/date/:/date --name 'c1' centos:7
[root@docker ~]# docker exec -it c1 /bin/bash
[root@2facb2656823 /]# echo "c1" > /date/a.txt 
[root@2facb2656823 /]# exit
[root@docker ~]# docker exec -it c2 /bin/bash
[root@b9fb9277ce20 /]# cat /date/a.txt 
c1

3.数据卷容器

1. 将容器挂载到另一个容器

   #语法：docker run --volumes-from DOCER_NAME...
   example:
    #创建数据卷容器和测试文件
    [root@docker ~]# docker run -it -v /docker/date:/date --name c1 centos:7
    [root@b9fb9277ce20 /]# echo "docker" > /date/a.txt
    [root@b9fb9277ce20 /]#exit
    #将数据卷容器挂载到c1 c2
    [root@docker ~]# docker run -id -volumes-from --name c2 centos:7
    [root@docker ~]# docker run -id -volumes-from --name c3 centos:7
    #登录c1 c2查看
    [root@docker ~]# docker exec -it c2 /bin/bash
    [root@9bc91f37fac0 /]# cat /date/a.txt
     docker
    [root@docker ~]# docker exec -it c3 /bin/bash
    [root@3632825b36c8 /]# cat /date/a.txt
     docker

   4.docker应用部署

   1.MySQL部署

2. 搜索拉取mysql

   [root@docker ~]# docker seach mysql
   [root@docker ~]# docker pull mysql:5.6

3. 创建mysql容器 ```shell 1.创建映射目录 [root@docker ~]# mkdir /docker/mysql -pv

2.创建mysql容器 [root@docker mysql]# docker run -id -p 3306:3306 —name mysql \ -v /docker/mysql/conf:/etc/mysql/conf.d \ #配置文件路径 -v /docker/mysql/data:/var/lib/mysql \ #数据文件

    > -v /docker/mysql/log:/var/log/mysql/ \    #日志文件
    -e MYSQL_ROOT_PASSWORD=123456 \                #指定密码，注意不指定容器会起不来
    mysql:5.6                                    #镜像

3.进入容器,修改密码 [root@docker mysql]# docker exec -it mysql /bin/bash root@6db43377ab98:/# mysqladmin -uroot password ‘123456’

4.修改登录地址 mysql> update mysql.user set host=’%’ where user=’root’;

注意docker的端口映射是使用防火墙的nat，不能关闭防火墙

3. 远程主机连接
```shell
[root@docker mysql]# mysql -uroot -p123456 -h192.168.10.101
MySQL [(none)]> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
| performance_schema |
+--------------------+

2.tomcat部署

1. 搜索拉取镜像

   [root@docker ~]# docker search tomcat
   [root@docker ~]# docker pull tomcat

2. 创建容器

   [root@docker ~]# mkdir /docker/tomcat -p
   [root@docker ~]# docker run -id --name tomcat -p 8080:8080 -v /docker/tomcat/html:/usr/local/tomcat/webapps tomcat

3. 配置网页文件

   root@eeb633798804:/usr/local/tomcat/# mkdir webapps/test
   root@eeb633798804:/usr/local/tomcat/# echo "hello docker tomcat" > index.html

   3.nginx部署

4. 拉去镜像

   [root@docker ~]# docker search nginx
   [root@docker ~]# docker pull nginx

5. 创建容器 ```shell

   创建主配置文件

   [root@docker ~]# mkdir /docker/nginx/ [root@docker ~]# vim nginx.conf

创建容器

[root@docker ~]# docker run -id —name nginx \ -v /docker/nginx/nginx.conf:/etc/nginx/nginx.conf \ #映射主配置文件，注意主配置文件需要事先创建 -v /docker/nginx/logs:/var/log/nginx \ #日志文件
-v /docker/nginx/html:/usr/share/nginx/html \ #网页文件 -p 80:80 nginx

3. 创建网页文件
```shell
[root@docker ~]# vim /docker/nginx/nginx.conf     #添加一段配置
server {
        listen       80;
        server_name  _;
        location / {
                root   /usr/share/nginx/html;
                index  index.html index.htm;
        }
}
[root@docker ~]# echo "nginx" > /docker/nginx/html/index.html

4.redis部署

1. 拉取redis镜像

   [root@docker html]# docker search redis
   [root@docker html]# docker pull redis

2. 创建容器

   [root@docker html]# docker run -id -v /docker/redis/date:/date --name redis -p 6379:6379 redis

   5.Dockerfile

   1.Docker镜像原理

3. linux文件系是由bootfs和rootfs组成
   bootfs：包含bootloader和kernel
   rootfs：root文件系统，典型的目录结构

4. dokcer镜像原理
   1. docker是由特殊的文件系统叠加而成的
   2. docker最底端是bootfs，而且它是复用宿主机的bootfs
   3. 第二层是rootfs，基础镜像，也就是我们的centos镜像，Ubuntu镜像
   4. 往上可以叠加更多的镜像文件，也就是应用软件
   5. 当容器启动时，docker会在最顶层加载一个读写文件系统作为容器；也就是可以生成新的镜像
5. 总结 ```shell

6. centos镜像小，因为它会复用宿主机bootfs

7. tomcat镜像比centos镜像大得多，因为他需要centos+jdk+tomcat，多层叠加 ```

   2.镜像制作

8. 容器转为镜像 ```shell docker commit 容器ID 新的镜像名:版本号 #制作新的镜像

docker save -o 压缩文件名 IMAGE_NAME:版本号 #压缩镜像

docker load -i 压缩文件名 #解压镜像

exmaple：将tomcat镜像修改，并且制作成新的镜像 1.创建一个镜像 [root@docker ~]# docker run-id -p 8080:8080 —name tomcat \ -v /docker/tomcat/html/:/usr/local/tomcat/webapps tomcat 创建tomcat容器
[root@docker docker]# docker exec -it tomcat bash #进入容器

2.创建测试文件
root@d866d:tomcat# echo “hello” > ./webapps/test/index.html        #创建网页文件,这是挂载到本地目录的
root@d866d3f86371:tomcat# echo “root” > /root/a.txt                #这是容器里面的
3.生成一个新的镜像
[root@docker ~]# docker commit d866 tomcat_test:1.0
[root@docker ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
tomcat_test         1.0                 b68698594b62        2 minutes ago       647MB
4.压缩解压镜像
[root@docker ~]# docker save -o tomcat_test.tar tomcat_test:1.0 
[root@docker ~]# docker rmi tomcat_test:1.0     #删除镜像
[root@docker ~]# docker load -i tomcat_test.tar        #解压镜像
5.使用新的镜像生产容器
[root@docker ~]# docker run -id --name tomcat tomcat_test:1.0
[root@docker ~]# docker exec -it tomcat bash
6.验证
root@74e:/usr/local/tomcat# ls /root/
a.txt
root@74:/usr/local/tomcat# ls webapps/
7.总结
挂载目录中的文件，不会随容器一起被制作成镜像，而容器里面创建的文件可以

<a name="22d08831"></a>
#### 3.Dockerfile制作镜像
1. Dockerfile概念
   1. Dockerfile是一个文本文件
   1. 包含了一条一条的指令
   1. 每一个指令构建一层，基于基础镜像，最终构建一个新的镜像
   1. 对于开发人员，可以为开发团队提供一个完全一致的开发环境
2. Dockerfile关键字
| 关键字 | 作用 | 备注 |
| :---: | :---: | :---: |
| FROM | 指定父镜像 | 指定Dockerfile基于那个image构建 |
| MAINTAINER | 作者信息 | 用来表明docker是谁写的 |
| LABEL | 标签 | 用来标明dockerfile的标签，可以使用label代替Maintainer,最红都是在docker image中查看 |
| RUN | 执行命令 | 执行一段指令，默认是bash格式，RUN command |
| CMD | 容器启动指令 | 提供启动容器时候的默认命令和ENTRYPOINT配合使用，CMD command param1 param2 |
| ENTRYPOINT | 入口 | 一般在制作一些执行就关闭的容器中会使用 |
| COPY | 复制文件 | build的时候复制文件到image中 |
| ADD | 添加文件 | build的时候添加文件到image中，不仅仅局限于当前build上下文，可来源于远程服务 |
| ENV | 环境变量 | 指定build时的环境变量，可以在启动容器的时候，通过-e覆盖，ENV name=value |
| ARG | 构建参数 | 只在构建参数时使用的参数，如果与ENV相同则被ENV负载 |
| VOLUME | 定义外部可以挂载的数据卷 | 指定build的image哪些目录可以启动的时候挂载到文件系统中，启动容器的时候使用 -v绑定 |
| EXPOSE | 暴露端口 | 定义容器运行的时候监听的端口，启动容器时使用-p绑定暴露的端口 EXPOSE 8080/tcp |
| WORDDIR | 工作目录 | 指定容器内部的工作目录 |
| USER | 指定执行用户 | 指定build或启动的时候，在RUN CMD ENTRYPOINT执行的时候的用户 |
| HEALTHCHECK | 健康检查 | 检测当前容器健康 |
| ONBUILD | 触发器 | 当存在ONBULID关键字的镜像作为基础镜像的时候，放当FROM完成之后，会触发 |
| STOPSIGNAL | 发送信号到宿主主机 | 该STOPSINGNAL指令设置将发送到容器的系统调用信号以退出 |
| SHELL | 执行脚本 | 指定RUN CMD ENTERYPOINT 执行命令的时候 使用的shell |
|  |  |  |
3. Dockerfile实战
```shell
#需求：自定义Centos7镜像，默认路径为/usr/ 可以使用vim指令
FROM centos:7                #定义父镜像
MAINTAINER                    #定义作者信息
RUN yum intsall -y vim        #安装vim
WORKDIR /usr                #指定默认工作目录
CMD /bin/bash                #容器启动时执行的命令
1.#定义dockerfile
[root@docker dockerfile]# vim centos_vim.df 
FROM centos:7
MAINTAINER
RUN yum intsall -y vim
WORKDIR /usr
CMD /bin/bash
2.#创建自定义镜像
[root@docker dockerfile]# docker build -f ./centos_vim.df  -t vim_centos:1 .    
[root@docker dockerfile]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
vim_centos          1                   851463a1038b        17 seconds ago      323MB
3.#使用自定义镜像创建文件
[root@docker ~]# docker run -it --name c1  vim_centos:1
[root@2b0820d547c8 usr]# which vim
/usr/bin/vim

6.Docker Compose

1.服务编排

微服务架构的应用系统中一般都包含若干个微服务，每个微服务部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。

• 从docker hub拉取镜像
• 创建多个container
• 管理多个container

  2.Docker Compose简介

1. Docker Compose是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建,启动停止。

• 利用dockerfile定义运行环境(镜像)
• 使用docker-compose.yml定义组成应用的各服务
• 运行docker-compose up启动应用

  3.Docker Compose安装

1. docker-compose在epel仓库中

   [root@docker ~]# yum install -y docker-compose

   4.Docker Compose实战

2. 需求，使用docker compose搭建lamp+wordpress环境

3. 软件版本httpd2.4 PHP5.4 MySQL5.6
4. 编写lamp.yaml

   [root@docker docker-compose]# vim lamp.yml

   7.Docker私有仓库

   1.私有仓库搭建

# 1.拉去私有仓库镜像
docker pull registry
# 2.创建私有仓库容器
docker run -id --name registry -p 5000:5000 registry
# 3.浏览器访问http://192.168.10.101:5000/v2/_catalog
# 4.修改daemon.json,让docker信任私有仓库
vim /etc/daemon.json
"insecure-registries": ["192.168.10.101:5000"]        #这一步配置在客户端，使docker信任这个私有docker仓库
# 5.重启docker服务
systemctl restart docker
docker start registry     #启动私有仓库
#注意：json语法格式，每一个key:value要使用‘.’逗号

2.将镜像上传至私有仓库

# 1.将需要上传的镜像打tag
 docker tag nginx 192.168.10.101:5000/nginx
# 2.上传镜像
 docker push 192.168.10.101:5000/nginx

3.从私有仓库拉去镜像

# 拉取镜像
docker pull  192.168.10.101:5000/nginx