windows Docker不用wsl docker没有yum

Docker学习

• 一、安装Docker

• 1、将yum 包更新到最新
• 2、安装需要的软件包，yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动的依赖
• 3、 设置yum源
• 4、 安装docker，出现输入的界面都按 y （==加入-y后能自动按y，使安装进程不会停下来等待执行==）
• 5、 查看docker版本，验证是否验证成功

• 二、配置阿里云镜像加速器（其他的也类似）

• 1、登录阿里云，点击控制台，找到三条横线，在里面搜索镜像，找到阿里云的镜像加速器，获取加速器地址
• 2、将下方对应操作系统的操作文档中的内容复制进窗口执行（这里是centos的操作系统）

• 三、和docker进程相关的命令

• 1、启动docker服务:
• 2、停止docker服务:
• 3、重启docker服务:
• 4、查看docker服务状态:
• 5、设置开机启动docker服务:

• 四、和docker镜像相关的命令

• 1、查看镜像: 查看本地所有的镜像
• 2、搜索镜像:从网络中查找需要的镜像（OFFICIAL表示官方镜像）
• 3、拉取镜像:从Docker仓库下载镜像到本地
• 4、删除镜像: 删除本地镜像

• 五、和Docker 容器相关的命令

• 1、查看容器
• 2、创建并启动容器
• 3、进入容器
• 4、停止容器
• 5、启动容器
• 6、删除容器：==如果容器是运行状态则删除失败，需要停止容器才能删除==
• 7、查看容器信息

• 六、Docker 容器的数据卷

• 1、配置数据卷

• 1.1、创建启动容器时，使用 –v 参数 设置数据卷
• 1.2、注意事项：

• 2、配置数据卷容器案例（==数据卷容器：多容器进行数据交换==）

• 2.1、创建并启动数据卷容器，`使用 –v 参数 设置数据卷`
• 2.2、创建启动两个容器，`使用 –-volumes-from 参数设置两个容器的数据卷，让其与数据卷容器绑定`

• 七、使用Docker 部署Mysql、Tomcat、Nginx、Redis等应用（大致步骤都相同）

• 1、MySQL部署

• 1.1、搜索mysql镜像
• 1.2、拉取mysql镜像
• 1.3、创建目录用于存储信息（可跳过这一步，后面重新指定）
• 1.4、创建容器，设置端口映射、目录映射
• 1.5、进入容器，操作mysql
• 1.6、可以使用外部机器连接容器中的mysql（可自测）

• 2、Tomcat部署

• 2.1、搜索tomcat镜像
• 2.2、拉取tomcat镜像
• 2.3、创建目录用于存储信息（可跳过这一步，后面重新指定）
• 2.4、创建容器，设置端口映射、目录映射
• 2.5、使用外部机器访问tomcat

• 3、Nginx部署

• 3.1、搜索nginx镜像
• 3.2、拉取nginx镜像
• 3.3、创建目录用于存储信息
• 3.4、创建容器，设置端口映射、目录映射
• 3.5、使用外部机器访问nginx

• 4、Redis部署

• 4.1、搜索redis镜像
• 4.2、拉取redis镜像
• 4.3、创建容器，设置端口映射
• 4.4、使用外部机器连接redis

• 八、将容器和镜像相互转换、通过Dockerfile制作镜像

• 1、容器与镜像之间的转换

• 1.1、容器转为镜像（==挂在的数据卷目录不会写入到镜像中，自己创建的目录才会写入到镜像中==）
• 1.2、镜像转为压缩文件
• 1.3、压缩文件还原为镜像

• 2、Dockerfile制作镜像案例（Dockerfile内容可以直接去[https://hub.docker.com/](https://hub.docker.com/)里查找自己需要的复制）

• 2.1、自定义centos7镜像。要求：
• 实现步骤
• 2.2、自定义dockerfile，发布SpringBoot的项目。
• 实现步骤

• 九、Docker 服务编排（服务编排： 按照一定的业务规则批量管理容器）【使用Docker Compose工具完成服务编排】

• 1、安装Docker Compose

• 1.1、 Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。
• 1.2、设置文件可执行权限
• 1.3、查看版本信息

• 2、卸载Docker Compose

• 2.1、二进制包方式安装的，删除二进制文件即可

• 3、使用docker compose编排nginx+springboot项目

• 3.1、创建docker-compose目录
• 3.2、编写 docker-compose.yml 文件【==名称固定，必须叫这个名字==】（使用 docker-compose.yml 定义组成应用的各服务）
• 3.3.、创建./nginx/conf.d目录，用于目录映射（数据卷）
• 3.4、在./nginx/conf.d目录下 编写：文件名称.conf文件
• 3.5、在~/docker-compose 目录下 使用docker-compose 启动容器
• 3.6、测试访问

• 十、搭建Docker 私有仓库

• 1、私有仓库搭建

• 1.1、拉取私有仓库镜像
• 1.2、启动私有仓库容器
• 1.3、打开浏览器 输入地址==http://私有仓库服务器ip:5000/v2/_catalog==，看到{"repositories":[]} 表示私有仓库 搭建成功
• 1.4、修改daemon.json
• 1.5、重启docker 服务

• 2、将镜像上传至私有仓库

• 2.1、标记镜像为私有仓库的镜像（只是打个标记不是上传）
• 2.2、上传标记的镜像

• 3、从私有仓库拉取镜像

• 3.1、拉取镜像

一、安装Docker

1、将yum 包更新到最新

yum update

2、安装需要的软件包，yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动的依赖

yum install -y yum-utils device-mapper-persistent-data lvm2

3、 设置yum源

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

4、 安装docker，出现输入的界面都按 y （加入-y后能自动按y，使安装进程不会停下来等待执行）

yum install -y docker-ce

5、 查看docker版本，验证是否验证成功

docker -v

二、配置阿里云镜像加速器（其他的也类似）

1、登录阿里云，点击控制台，找到三条横线，在里面搜索镜像，找到阿里云的镜像加速器，获取加速器地址

2、将下方对应操作系统的操作文档中的内容复制进窗口执行（这里是centos的操作系统）

三、和docker进程相关的命令

1、启动docker服务:

systemctl start docker

2、停止docker服务:

systemctl stop docker

3、重启docker服务:

systemctl restart docker

4、查看docker服务状态:

systemctl status docker

5、设置开机启动docker服务:

systemctl enable docker

四、和docker镜像相关的命令

1、查看镜像: 查看本地所有的镜像

docker images
docker images -q # 查看所有镜像的id

2、搜索镜像:从网络中查找需要的镜像（OFFICIAL表示官方镜像）

docker search 镜像名称

3、拉取镜像:从Docker仓库下载镜像到本地

（如果不知道镜像版本，可以去docker hub 搜索对应镜像查看。）

docker pull 镜像名称:版本号【如果版本号不指定则是最新的版本。】

4、删除镜像: 删除本地镜像

docker rmi 镜像id（或者指定镜像名称：版本也能删除）  # 删除指定本地镜像

【在删除镜像前要先删除由镜像创建的容器，在删除镜像，或者加参数强制删除镜像】

docker rmi `docker images -q` # 删除所有本地镜像（这个是组合命令）

五、和Docker 容器相关的命令

1、查看容器

docker ps  # 查看正在运行的容器
docker ps -a  # 查看所有容器

2、创建并启动容器

docker run 参数（例如：docker run -it --name=容器名 镜像名：版本 /bin/bash）

参数说明：

• -i：保持容器运行。通常与 -t 同时使用。加入it这两个参数后，容器创建后自动进入容器中。退出后，容器自动关闭。
• -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用。
• -d：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec 进入容器。退出后，容器不会关闭。
• -it 创建的容器一般称为交互式容器，-id 创建的容器一般称为守护式容器
• –name：为创建的容器命名。
• /bin/bash【或bash】：开启一个bash终端，或者叫shell窗口脚本【centos镜像创建容器默认加入/bin/bash】

3、进入容器

docker exec 参数（参数一般是-it 容器名字 /bin/bash） # exit退出容器

4、停止容器

docker stop 容器名称（或id）

5、启动容器

docker start 容器名称（或id）

6、删除容器：如果容器是运行状态则删除失败，需要停止容器才能删除

docker rm 容器名称（或id）

7、查看容器信息

docker inspect 容器名称（或id）

六、Docker 容器的数据卷

数据卷：

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

数据卷作用：

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

1、配置数据卷

1.1、创建启动容器时，使用 –v 参数 设置数据卷

docker run ... –v 宿主机目录(文件):容器内目录(文件) ...

1.2、注意事项：

1. 目录必须是绝对路径
2. 如果目录不存在，会自动创建
3. 可以挂载多个数据卷

2、配置数据卷容器案例（数据卷容器：多容器进行数据交换）

docker run –it --name=容器名称 –v 容器目录 镜像名称:版本 /bin/bash

【docker会在宿主机上自动分配一个目录当作数据卷目录，所以宿主机目录可以不指定】

2.1、创建并启动数据卷容器，使用 –v 参数 设置数据卷

2.2、创建启动两个容器，使用 –-volumes-from 参数设置两个容器的数据卷，让其与数据卷容器绑定

docker run –it --name=c1 --volumes-from c3 centos:7 /bin/bash

七、使用Docker 部署Mysql、Tomcat、Nginx、Redis等应用（大致步骤都相同）

1、MySQL部署

1.1、搜索mysql镜像

docker search mysql

1.2、拉取mysql镜像

docker pull mysql:5.6

1.3、创建目录用于存储信息（可跳过这一步，后面重新指定）

（在/root目录下创建mysql目录用于存储mysql数据信息）

mkdir ~/mysql
cd ~/mysql

1.4、创建容器，设置端口映射、目录映射

docker run -id \
-p 3307:3306 \
--name=c_mysql \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:5.6

参数说明：

• -p 3307:3306：将容器的 3306 端口映射到宿主机的 3307 端口。
• -v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
• -v $PWD/logs:/logs：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
• -v $PWD/data:/var/lib/mysql ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
• -e MYSQL_ROOT_PASSWORD=123456：初始化 root 用户的密码。

1.5、进入容器，操作mysql

docker exec –it c_mysql /bin/bash

1.6、可以使用外部机器连接容器中的mysql（可自测）

2、Tomcat部署

2.1、搜索tomcat镜像

docker search tomcat

2.2、拉取tomcat镜像

docker pull tomcat

2.3、创建目录用于存储信息（可跳过这一步，后面重新指定）

mkdir ~/tomcat（在/root目录下创建tomcat目录用于存储tomcat数据信息）
cd ~/tomcat

2.4、创建容器，设置端口映射、目录映射

docker run -id --name=c_tomcat \
-p 8080:8080 \
-v $PWD:/usr/local/tomcat/webapps \
tomcat

参数说明：

• -p 8080:8080：**将容器的8080端口映射到主机的8080端口
• -v $PWD:/usr/local/tomcat/webapps：**将主机中当前目录挂载到容器的webapps

2.5、使用外部机器访问tomcat

3、Nginx部署

3.1、搜索nginx镜像

docker search nginx

3.2、拉取nginx镜像

docker pull nginx

3.3、创建目录用于存储信息

mkdir ~/nginx【在/root目录下创建nginx目录用于存储nginx数据信息】
cd ~/nginx
mkdir conf【在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容】
cd conf
vim nginx.conf

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    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;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

3.4、创建容器，设置端口映射、目录映射

docker run -id --name=c_nginx \
-p 80:80 \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx

参数说明：

• -p 80:80：将容器的 80端口映射到宿主机的 80 端口。
• -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
• -v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录

3.5、使用外部机器访问nginx

4、Redis部署

4.1、搜索redis镜像

docker search redis

4.2、拉取redis镜像

docker pull redis:5.0

4.3、创建容器，设置端口映射

docker run -id --name=c_redis -p 6379:6379 redis:5.0

4.4、使用外部机器连接redis

八、将容器和镜像相互转换、通过Dockerfile制作镜像

1、容器与镜像之间的转换

1.1、容器转为镜像（挂在的数据卷目录不会写入到镜像中，自己创建的目录才会写入到镜像中）

docker commit 容器id 镜像名称:版本号

1.2、镜像转为压缩文件

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

1.3、压缩文件还原为镜像

docker load –i 压缩文件名称

2、Dockerfile制作镜像案例（Dockerfile内容可以直接去https://hub.docker.com/里查找自己需要的复制）

2.1、自定义centos7镜像。要求：

1】默认登录路径为/usr
2】可以使用vim

实现步骤

① 定义父镜像：FROM centos:7
② 定义作者信息（这个除了关键字，其他可随便写）：MAINTAINER 名称 <邮箱>
③ 执行安装vim命令： RUN yum install -y vim（-y会自动选择安装过程中的y，保证安装顺利进行）
④ 定义默认的工作目录：WORKDIR /usr
⑤ 定义容器启动执行的命令：CMD /bin/bash
⑥ 通过dockerfile构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本 .【这个.是一个寻址路径】

2.2、自定义dockerfile，发布SpringBoot的项目。

实现步骤

① 定义父镜像：FROM java:8
② 定义作者信息（这个除了关键字，其他可随便写）：MAINTAINER 名称 <邮箱>
③ 将jar包添加到容器： ADD jar包完整名称（这里是提前准备好的springboot.jar） 容器中的jar包全名称（这里是app.jar）
④ 定义容器启动执行的命令：CMD java -jar app.jar
⑤ 通过dockerfile构建镜像：docker build -f dockerfile文件路径 –t 镜像名称:版本

九、Docker 服务编排（服务编排： 按照一定的业务规则批量管理容器）【使用Docker Compose工具完成服务编排】

1、安装Docker Compose

1.1、 Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。

curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

1.2、设置文件可执行权限

chmod +x /usr/local/bin/docker-compose

1.3、查看版本信息

docker-compose -version

2、卸载Docker Compose

2.1、二进制包方式安装的，删除二进制文件即可

rm /usr/local/bin/docker-compose

3、使用docker compose编排nginx+springboot项目

3.1、创建docker-compose目录

mkdir ~/docker-compose
cd ~/docker-compose

3.2、编写 docker-compose.yml 文件【名称固定，必须叫这个名字】（使用 docker-compose.yml 定义组成应用的各服务）

version: '3'
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"

（lingks: -app：nginx反向代理，通过挂载到的app，去执行对应的app容器，根据文件配置从而可以一次性启动多个容器）

3.3.、创建./nginx/conf.d目录，用于目录映射（数据卷）

mkdir -p ./nginx/conf.d

3.4、在./nginx/conf.d目录下 编写：文件名称.conf文件

cd ./nginx/conf.d

server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}

3.5、在~/docker-compose 目录下 使用docker-compose 启动容器

cd ~/docker-compose
docker-compose up

3.6、测试访问

http://IP/hello

十、搭建Docker 私有仓库

1、私有仓库搭建

1.1、拉取私有仓库镜像

docker pull registry

1.2、启动私有仓库容器

docker run -id --name=容器名 -p 宿主机端口（一般和容器端口相同）:5000 registry

1.3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{“repositories”:[]} 表示私有仓库 搭建成功

1.4、修改daemon.json

vim /etc/docker/daemon.json

在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip

{"insecure-registries":["私有仓库服务器ip:宿主机端口（一般和容器端口相同）"]}

1.5、重启docker 服务

systemctl restart docker
docker start 容器名

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

2.1、标记镜像为私有仓库的镜像（只是打个标记不是上传）

docker tag 镜像名：版本 私有仓库服务器IP:宿主机端口（一般和容器端口相同）/名字：版本

2.2、上传标记的镜像

docker push 私有仓库服务器IP:宿主机端口（一般和容器端口相同）/名称：镜像版本【私有仓库服务器IP:宿主机端口（一般和容器端口相同）/名称这个就是tag标记的名字，其实也就是镜像名字】

3、从私有仓库拉取镜像

3.1、拉取镜像

docker pull 私有仓库服务器ip:宿主机端口（一般和容器端口相同）/名称:版本