Docker

一、初始Docker

1. 什么是Docker

1.1 传统项目部署的问题

大型项目组件较多，运行环境也较为复杂，部署时会碰到一些问题：
- 依赖关系复杂，容易出现兼容性问题
- 开发、测试、生产环境有差异

1.2 Docker

Docker如何解决依赖的兼容问题？
- 将应用的Libs（函数库）、Deps（依赖）、配置与应用一起打包
- 将每一个应用放到一个隔离容器去运行，避免互相干扰
Docker如何解决不同系统环境的问题？
- Docker将用户程序与所需调用的系统（比如Ubuntu）函数库一起打包
- Docker运行到不同操作系统时，直接基于打包的库函数，借助于操作系统的Linux内核来运行
Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？
- Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
- Docker应用运行在容器中，使用沙箱机制，相互隔离
Docker如何解决开发、测试、生产环境差异的问题
- Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行
总结
- Docker是一个快速交付应用、运行应用的技术：
  - 可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统
  - 运行时利用沙箱机制形成隔离容器，各个应用互不干扰
  - 启动、移除都可以通过一行命令完成，方便快捷

2. Docker和虚拟机的区别

虚拟机（virtual machine）是在操作系统中模拟硬件设备，然后运行另一个操作系统，比如在Windows系统里运行Ubuntu系统，这样就可以运行任意的Ubuntu应用了。

Docker与虚拟机

特性 Docker 虚拟机
性能接近原生性能较差
硬盘占用一般为MB 一般为GB
启动秒级分钟级
Docker和虚拟机的差异：
- Docker是一个系统进程，虚拟机是在操作系统中的操作系统
- Docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般

特性	Docker	虚拟机
性能	接近原生	性能较差
硬盘占用	一般为MB	一般为GB
启动	秒级	分钟级

3. Docker架构

3.1 镜像和容器

镜像（image）：Docker将应用程序及其所需要的依赖、函数库、环境、配置等文件打包在一起，称之为镜像。
容器（container）：镜像中的应用程序运行形成的进程就是容器，只是Docker会给容器做隔离，对外不可见。

3.2 Docker和DockerHub

DockerHub：DockerHub是一个Docker镜像的托管平台。这样的平台称之为Docker Registry。
国内也有类似于DockerHub的公开服务，比如网易云镜像服务、阿里云镜像库等

3.3 Docker架构

Docker是一个CS架构的程序，由两部分组成：
- 服务端（Server）：Docker守护进程，负责处理Docker指令，管理镜像、容器等
- 客户端（Client）：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

3.4 总结

镜像
- 将应用程序及其依赖、环境、配置打包在一起
容器
- 镜像运行起来就是容器，一个镜像可以运行多个容器
Docker结构
- 服务端：接收命令或远程请求，操作镜像或容器
- 客户端：发送命令或者请求到Docker服务端
DockerHub
- 一个镜像托管的服务器，类似的还有阿里云镜像服务，统称为DockerRegister

4. 安装Docker-基于CentOS8

Docker 分为 CE 和 EE 两大版本。CE 即社区版（免费，支持周期 7 个月），EE 即企业版，强调安全，付费使用，支持周期 24 个月。
Docker CE 分为 stable 、test 和 nightly 三个更新频道
官方网站上有各种环境下的安装指南，这里主要介绍 Docker CE 在 CentOS上的安装。
- 网址：https://docs.docker.com/desktop/install/linux/

4.1 CentOS安装Docker

Docker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10， CentOS 7 满足最低内核的要求，所以我们在CentOS 7安装Docker。

4.2 卸载Docker（可选）

如果之前安装过旧版本的Docker，可以使用下面命令卸载：

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

4.3 安装Docker指令-基于CentOS-8

首先需要虚拟机联网，安装yum工具

已经有了则不需要安装

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

更新本地镜像源

# 设置docker镜像源
 yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#将Docker的官方仓库地址替换为阿里云的镜像仓库地址
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

#生成更新本地缓存
yum makecache fast
#如果上一条指令执行不了，则使用下面这条指令
yum makecache

执行安装指令
```
yum install -y docker-ce
```

4.4 启动Docker

通过命令启动docker

systemctl start docker  # 启动docker服务

systemctl enable docker # 设置开机自启

systemctl stop docker  # 停止docker服务

systemctl restart docker  # 重启docker服务

查看Docker版本信息
```
docker -v
```

4.5 配置镜像加速

docker官方镜像仓库网速较差，我们需要设置国内镜像服务：
参考阿里云的镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

二、Docker的基本操作

1. 镜像操作

官方网址：https://hub.docker.com/
镜像名称一般分为两个部分组成：[repository]:[tag]
在没有指定tag时，默认是latest，代表最新版本的镜像

镜像操作命令

构建镜像-指令
```
docker build [REPOSITORY[:TAG]]
```

查看镜像-指令

docker  images [OPTIONS] [REPOSITORY[:TAG]]

删除镜像-指令
```
docker rmi [OPTIONS] IMAGE [IMAGE...]
```
推送镜像到服务-指令
```
docker push [OPTIONS] NAME[:TAG]
```

从服务拉取镜像-指令

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

保存镜像为一个压缩包-指令
```
docker save [OPTIONS] IMAGE [IMAGE...]
```
加载压缩包为镜像-指令
```
docker load [OPTIONS] IMAGE
```

操作案例
- 需求：从DockerHub中拉取一个nginx镜像并查看
  - 去官方网址搜索想要的镜像
  - 然后去拉取镜像
    - 没有配置tag默认是是latest
```
docker pull nginx
```
  - 然后查看镜像
```
docker images
```
- 需求：利用docker save将nginx镜像导出磁盘，然后再通过load加载回来
  - 利用docker xx --help命令查看docker save和docker load的语法
```
docker save --help
```
    - 命令格式
```
# -o 选项表示指定保存文件要保存在哪个目录下，不指定默认在当前目录下
# 只能保存成tar格式文件
docker save -o [保存的目标文件名称] [repository:tag]
```
  - 使用docker save导出镜像到磁盘
```
docker save -o nginx.tar nginx:latest
```
  - 使用docker load加载镜像
    - 删除原先拉取的镜像
```
docker rmi nginx:latest
```
    - 然后加载之前保存的文件
```
docker load -i nginx.tar
```

2. 容器操作

2.1 容器相关命令

运行容器-指令
```
docker run 
```
暂停容器-指令
```
docker pause
```
停止暂停容器-指令
```
docker unpause
```
停止容器-指令
```
docker stop
```
启动容器-指令
```
docker start
```
进入容器执行命令
```
docker exec
```
查看容器运行日志
```
docker logs
```
查看所有运行的容器及其状态
```
docker ps
```
删除指定容器
```
docker rm
```

2.2 案例演示

需求：创建运行一个Nginx容器
```
docker run --name some-nginx -d -p 8080:80 some-content-nginx
```
- 命令解读
  - docker run：创建并运行一个容器
  - --name：给容器起一个名称，比如：dev-nginx
  - -d：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
  - -p：后台运行，如果不使用后台运行，只要关掉Xshell就会停止运行这个容器
  - some-content-nginx：指定要运行哪个镜像
需求：进入Nginx容器，修改HTML文件内容，添加“欢迎您”
```
docker exec -it dev-nginx bash
```
- 命令解读
  - docker exec ：进入容器内部，执行一个命令
  - -i：保持 STDIN 打开，即使没有附加到终端
  - -t ：分配一个伪终端 (pseudo-TTY)。
  - -it：给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
  - dev-nginx：要进入的容器的名称
  - bash：是要在容器内执行的命令。这里我们启动了一个 Bash shell，以便我们可以与容器进行交互。
- 进入nginx的HTML所在目录 /usr/share/nginx/html
  - 容器内部会模拟一个独立的Linux文件系统，看起来如同一个linux服务器一样：
  - nginx的环境、配置、运行文件全部都在这个文件系统中，包括我们要修改的html文件。
  - 查看DockerHub网站中的nginx页面，可以知道nginx的html目录位置在/usr/share/nginx/html
  - 执行进入该/usr/share/nginx/html的指令
```
cd /usr/share/nginx/html
```
  - 修改index.html的内容
    - 容器内没有vi命令，无法直接修改，使用用下面的命令来修改：
```
sed -i -e 's#Welcome to nginx#欢迎您#g' index.html
sed -i -e 's#<head>#<head><meta charset="utf-8">#g' index.html
```

3. 数据卷（容器数据管理）

3.1 容器与数据耦合问题

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

3.2 数据卷

数据卷：是一个虚拟目录，指向宿主机文件系统中的某个文件
操作数据卷
- 数据卷操作的基本语法如下：
```
docker volume [command]
```
- docker volume命令是数据卷操作，根据命令后跟随的command来确定下一步的操作
  - create：创建一个volume
  - inspect：显示一个或多个volume的信息
  - ls：列出所有的volume
  - prune：删除未使用的volume
  - rm：删除一个或多个指定的volume

3.3 案例演示

需求：创建一个数据卷，并查看数据卷在宿主机的目录位置
- 创建数据卷
```
docker volume create html
```
- 查看所有数据
```
docker voluem ls
```
- 查看数据卷详细信息卷
```
docker volume inspect html
```

3.4 挂载数据卷

在创建容器时，可以通过-v 参数来挂载一个数据卷到某个容器目录
举例说明
```
docker run --name dev-redis -v html:/root/html -p 6379:6379  -d redis redis-server --save 60 1 
```
- docker run：就是创建并运行容器
- --name：给容器起一个名称，比如：dev-nginx
- -d：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
- -p：后台运行，如果不使用后台运行，只要关掉Xshell就会停止运行这个容器
- --save：选项用于配置 Redis 的 RDB（Redis DataBase）持久化策略。RDB 持久化会在指定的时间间隔内将 Redis 数据库的快照保存到磁盘上的一个文件中
- --save 60 1：表示每 60 秒如果有 1 个或更多的键发生了变化，则保存一次数据到磁盘。
- redis：指定要运行哪个镜像
- redis-server：这是要在容器内运行的命令。表示启动 Redis 服务器
- -v：表示把数据卷挂载到指定的容器目录中，:左边是数据卷中的目录，右边是容器中的目录，如果目录不存在会自动创建

3.4.1 案例演示

需求：创建一个nginx容器，修改容器内的html目录内的index.html内容
- 分析：上个案例中，我们进入nginx容器内部，已经知道nginx的html目录所在位置/usr/share/nginx/html ，我们需要把这个目录挂载到html这个数据卷上，方便操作其中的内容
  - 创建容器并挂载数据卷到容器内的HTML目录
```
docker run --name dev-nginx -v html:/usr/share/nginx/html -p 80:80 -d nginx
```
  - 进入html数据卷所在位置，并修改HTML内容
  - 首先查看html数据卷的详细位置
```
docker volume inspect html
```
  - 进入目标目录
```
cd /var/lib/docker/volume/html/_data
```
  - 修改index.html文件
```
vim /var/lib/docker/volume/html/_data/index.html
```

4 挂载宿主目录和文件

1. 与数据卷方式对比

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上。关联关系如下：
- 带数据卷模式：宿主机目录 --> 数据卷 ---> 容器内目录
- 直接挂载模式：宿主机目录 ---> 容器内目录
语法：
- 目录挂载与数据卷挂载的语法是类似的
  - -v [宿主机目录]:[容器内目录]
  - -v [宿主机文件]:[容器内文件]

2. 案例演示

需求：创建并运行一个MySQL容器，将宿主机目录直接挂载到容器
实现思路如下：
- 从docker Hub上拉取镜像
- 创建目录/tmp/mysql/data
- 创建目录/tmp/mysql/conf，并将配置文件hmy.cnf上传到/tmp/mysql/conf
- 去DockerHub查阅资料，创建并运行MySQL容器，要求:
  - 挂载/tmp/mysql/data到mysql容器内数据存储目录
  - 挂载/tmp/mysql/conf/hmy.cnf到mysql容器的配置文件
  - 设置MySQL密码

实现步骤：

首选创建data和conf目录

mkdir -p /tmp/mysql/data
mkdir -p /tmp/mysql/conf

然后通过Xftp上传文件hmy.cnf

然后运行mysql镜像

docker run --name dev-mysql -v /tmp/mysql/data:/var/lib/mysql -v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf -e  MYSQL_ROOT_PASSWORD=root  -p 3306:3306 -d mysql

3. 数据卷挂载与目录直接挂载的对比

数据卷挂载耦合度低，由docker来管理目录，但是目录较深，不好找
目录挂载耦合度高，需要我们自己管理目录，不过目录容易寻找查看

三、Dockerfile自定义镜像

常见的镜像在DockerHub就能找到，但是我们自己写的项目就必须自己构建镜像了
而要自定义镜像，就必须先了解镜像的结构才行。

1. 镜像结构

镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成
以MySQL为例，来看看镜像的组成结构：
总结：
- 镜像是分层结构，每一层称为一个Layer
  - BaseImage层：包含基本的系统函数库、环境变量、文件系统
  - Entrypoint：入口，是镜像中应用启动的命令
  - 其它：在BaseImage基础上添加依赖、安装程序、完成整个应用的安装和配置

2. Dockerfile语法

什么是Dockerfile
- 构建自定义的镜像时，并不需要一个个文件去拷贝，打包
- 只需要告诉Docker，镜像的组成，需要哪些BaseImage、需要拷贝什么文件、需要安装什么依赖、启动脚本是什么，将来Docker会帮助我们构建镜像。
- 而描述上述信息的文件就是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/reference/dockerfile. 构建Java项目

3. 构建Java项目

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

新建一个空文件夹docker-demo
```
mkdir docker-demo
```
拷贝docker-demo.jar和jdk8.tar.gz文件到docker-demo这个目录

拷贝Dockerfile到docker-demo这个目录

文件内容如下

#指定基础镜像
FROM ubuntu:16.04
#配置安装环境，JDK的安装目录
ENV JAVA_DIR=/usr/local/jdk

#拷贝JDK和java项目的包到安装目录
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /usr/local/java/app.jar

#安装JDK
RUN cd $JAVA_DIR \ 
&& tar -zxvf ./jdk8.tar.gz \
&& mv ./jdk1.8.0_144 ./jdk8

#配置环境变量
ENV JAVA_HOME=$JAVA_DIR/jdk8
ENV PATH=$PATH:$JAVA_HOME/bin

#暴露端口
EXPOSE 8090

#入口，启动JAVA项目的命令
ENTRYPOINT java -jar /usr/local/java/app.jar

进入docker-demo
```
cd /root/docker-demo
```
运行命令
```
docker build -t javaweb:4.0 .
```
- 说明
  - 指令中的**.**表示当前目录，如果Dockerfile不是在当目录的话，要指定存放Dockerfile文件的目录，也要注意Dockerfile配置文件中配置的拷贝目录是否符合路径要求，否则会报错
  - -t：表示加载后，指定自定义的镜像的名称[repository]:[tag]

4.基于java8构建Java项目

虽然我们可以基于Ubuntu基础镜像，添加任意自己需要的安装包，构建镜像，但是却比较麻烦。所以大多数情况下，我们都可以在一些安装了部分软件的基础镜像上做改造
例如，构建java项目的镜像，可以在已经准备了JDK的基础镜像基础上构建。
需求：基于java:8-alpine镜像，将一个Java项目构建为镜像
- 实现思路如下：
  - 在Linux系统中创建一个新的目录上传Dockerfile
  - 拷贝docker-demo.jar到这个目录中
  - 修改Dockerfile文件
    - 基于java:8-alpine作为基础镜像
    - 将app.jar拷贝到镜像中
    - 暴露端口
    - 编写入口ENTRYPOINT
    - 内容如下
```
#指定基础镜像
FROM openjdk:8-alpine

COPY ./docker-demo.jar /usr/local/java/app.jar

#暴露端口
EXPOSE 8090

#入口，启动JAVA项目的命令
ENTRYPOINT java -jar /usr/local/java/app.jar
```

四、Docker-Compose

1. 基本介绍

Docker Compose可以基于Compose文件帮我们快速的部署分布式应用，而无需手动一个个创建和运行容器！
Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行。格式如下
```
 services:
  mysql:
    image: mysql:5.7.25
    environment:
     MYSQL_ROOT_PASSWORD: 123 
    volumes:
     - "/tmp/mysql/data:/var/lib/mysql"
     - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
  web:
    build: .
    ports:
     - "8090:8090"
```
- 上面的Compose文件就描述一个项目，其中包含两个容器：
  - mysql：一个基于mysql:5.7.25镜像构建的容器，并且挂载了两个目录
  - web：一个基于docker build临时构建的镜像容器，映射端口时8090
DockerCompose的详细语法参考官网：https://docs.docker.com/compose/intro/compose-application-model/

2. 安装Compose

Linux下需要通过命令下载：

curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

修改文件权限：

# 修改权限
chmod +x /usr/local/bin/docker-compose

Base自动补全命令

curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

如果这里出现错误，需要修改自己的hosts文件：

echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

3.部署微服务集群

实现思路：
- 查看提供的cloud-demo文件夹，里面已经编写好了docker-compose文件
- 修改cloud-demo项目，将数据库、nacos地址都命名为docker-compose中的服务名
- 使用maven打包工具，将项目中的每个微服务都打包为app.jar
- 将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录中
- 将cloud-demo上传至虚拟机，利用 docker-compose up -d 来部署
compose文件
- 查看提供的cloud-demo文件夹，里面已经编写好了docker-compose文件，而且每个微服务都准备了一个独立的目录：
  - 文件内容如下
```
#需要启动的服务
services:
#nacos服务
  nacos:
  #配置镜像
    image: nacos/nacos-server
    #配置环境变量
    environment:
      MODE: standalone
    #配置端口
    ports:
      - "8848:8848"
  #配置Mysql
  mysql:
  #配置镜像
    image: mysql:5.7.25
	#配置环境变量    
    environment:
      MYSQL_ROOT_PASSWORD: 123
    #挂载目录
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"
      - "$PWD/mysql/conf:/etc/mysql/conf.d/"
 #服务名称  
  userservice:
  #加载服务及其路径
    build: ./user-service
  orderservice:
    build: ./order-service
  gateway:
    build: ./gateway
    ports:
      - "10010:10010"
```
  - 可以看到，其中包含5个service服务：
    - nacos：作为注册中心和配置中心
      - image: nacos/nacos-server：基于nacos/nacos-server镜像构建
      - environment：环境变量
        
        MODE: standalone：单点模式启动
      - ports：端口映射，这里暴露了8848端口
    - mysql：数据库
      - image: mysql:5.7.25：镜像版本是mysql:5.7.25
      - environment：环境变量
        
        MYSQL_ROOT_PASSWORD: 123：设置数据库root账户的密码为123
      - volumes：数据卷挂载，这里挂载了mysql的data、conf目录，其中有我提前准备好的数据
    - userservice、orderservice、gateway：都是基于Dockerfile临时构建的

查看微服务目录，可以看到都包含Dockerfile文件：

FROM openjdk:8-alpine
COPY ./app.jar /tmp/app.jar
ENTRYPOINT java -jar /tmp/app.jar

修改微服务配置
- 因为微服务将来要部署为docker容器，而容器之间互联不是通过IP地址，而是通过容器名。这里我们将order-service、user-service、gateway服务的mysql、nacos地址都修改为基于容器名的访问。
打包
- 接下来需要将我们的每个微服务都打包。因为之前查看到Dockerfile中的jar包名称都是app.jar，因此我们的每个微服务都需要用这个名称
拷贝jar包到部署目录
- 译打包好的app.jar文件，需要放到Dockerfile的同级目录中。注意：每个微服务的app.jar放到与服务名称对应的目录。
部署
- 最后，需要将文件整个cloud-demo文件夹上传到虚拟机中，由DockerCompose部署。
- 上传到任意目录
- 然后进入cloud-demo目录，然后运行下面的命令
```
docker-compose up -d
```

五、Docker镜像服务

1. 常见镜像仓库服务

镜像仓库（ Docker Registry ）有公共的和私有的两种形式：
- 公共仓库：例如Docker官方的 Docker Hub，国内也有一些云服务商提供类似于 Docker Hub 的公开服务，比如网易云镜像服务、DaoCloud 镜像服务、阿里云镜像服务等
- 除了使用公开仓库外，用户还可以在本地搭建私有 Docker Registry。企业自己的镜像最好是采用私有Docker Registry来实现

2. 搭建私有镜像仓库

搭建镜像仓库可以基于Docker官方提供的DockerRegistry来实现。
- 官方网址：https://hub.docker.com/_/registry

2.1 简化版镜像仓库

Docker官方的Docker Registry是一个基础版本的Docker镜像仓库，具备仓库管理的完整功能，但是没有图形化界面。
- 搭建方式比较简单，命令如下：
```
docker run -d \
    --restart=always \
    --name registry	\
    -p 5000:5000 \
    -v registry-data:/var/lib/registry \
    registry
```
- 命令中挂载了一个数据卷registry-data到容器内的/var/lib/registry 目录，这是私有镜像库存放数据的目录。
- 访问http://主机IP:5000/v2/_catalog 可以查看当前私有镜像服务中包含的镜像

2.2 带有图形化界面版本

使用DockerCompose部署带有图象界面的DockerRegistry，命令如下：

version: '3.8'

services:
  registry-ui:
    image: joxit/docker-registry-ui:main
    restart: always
    ports:
      - 8080:80
    environment:
      - SINGLE_REGISTRY=true
      - REGISTRY_TITLE=学习私人镜像
      - DELETE_IMAGES=true
      - SHOW_CONTENT_DIGEST=true
      - NGINX_PROXY_PASS_URL=http://registry-server:5000
      - SHOW_CATALOG_NB_TAGS=true
      - CATALOG_MIN_BRANCHES=1
      - CATALOG_MAX_BRANCHES=1
      - TAGLIST_PAGE_SIZE=100
      - REGISTRY_SECURED=false
      - CATALOG_ELEMENTS_LIMIT=1000
    container_name: registry-ui

  registry-server:
    image: registry:2.8.2
    restart: always
    environment:
      REGISTRY_HTTP_HEADERS_Access-Control-Allow-Origin: '[http://192.168.180.130:8080]'
      REGISTRY_HTTP_HEADERS_Access-Control-Allow-Methods: '[HEAD,GET,OPTIONS,DELETE]'
      REGISTRY_HTTP_HEADERS_Access-Control-Allow-Credentials: '[true]'
      REGISTRY_HTTP_HEADERS_Access-Control-Allow-Headers: '[Authorization,Accept,Cache-Control]'
      REGISTRY_HTTP_HEADERS_Access-Control-Expose-Headers: '[Docker-Content-Digest]'
      REGISTRY_STORAGE_DELETE_ENABLED: 'true'
    volumes:
      - ./registry/data:/var/lib/registry
    container_name: registry-server

2.3.配置Docker信任地址

我们的私服采用的是http协议，默认不被Docker信任，所以需要做一个配置：

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.150.101:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

3. 推送、拉取镜像

推送镜像到私有镜像服务必须先tag，步骤如下：
- 重新tag本地镜像，名称前缀为私有仓库的地址：192.168.180.130:8080/
```
docker tag nginx:latest 192.168.180.130:8080/nginx:1.0 
```
- 推送镜像
```
docker push 192.168.180.130:8080/nginx:1.0 
```
- 拉取镜像
```
docker pull 192.168.180.130:8080/nginx:1.0 
```

Share

Docker

Docker

一、初始Docker

1. 什么是Docker

1.1 传统项目部署的问题

1.2 Docker

2. Docker和虚拟机的区别

3. Docker架构

3.1 镜像和容器

3.2 Docker和DockerHub

3.3 Docker架构

3.4 总结

4. 安装Docker-基于CentOS8

4.1 CentOS安装Docker

4.2 卸载Docker（可选）

4.3 安装Docker指令-基于CentOS-8

4.4 启动Docker

4.5 配置镜像加速

二、Docker的基本操作

1. 镜像操作

2. 容器操作

2.1 容器相关命令

2.2 案例演示

3. 数据卷（容器数据管理）

3.1 容器与数据耦合问题

3.2 数据卷

3.3 案例演示

3.4 挂载数据卷

3.4.1 案例演示

4 挂载宿主目录和文件

1. 与数据卷方式对比

2. 案例演示

3. 数据卷挂载与目录直接挂载的对比

三、Dockerfile自定义镜像

1. 镜像结构

2. Dockerfile语法

3. 构建Java项目

4.基于java8构建Java项目

四、Docker-Compose

1. 基本介绍

2. 安装Compose

3.部署微服务集群

五、Docker镜像服务

1. 常见镜像仓库服务

2. 搭建私有镜像仓库

2.1 简化版镜像仓库

2.2 带有图形化界面版本

2.3.配置Docker信任地址

3. 推送、拉取镜像

Comment