Docker容器相关

@[toc]目录

概述

Docker核心对象

Docker 应用架构分析

架构图

Docker运行机制docker pull 执行过程：

 Docker指令

离线安装Docker

 Docker服务基本操作

Docker数据管理 

数据卷

数据卷操作

Dockerfile及镜像制作实践

准备工作

Dockfile文件

 制作Sentinel镜像

安装MySql数据库

安装步骤

安装Redis数据库

安装步骤

访问redis服务器

安装Ngnix代理

安装Ngnix组件

安装步骤

Docker 容器互联

初始化网络

查看网络信息

实现容器互联

创建容器

测试网络互通

---

#概述

Docker是一个虚拟化平台( 官网https://www.docker.com/)，诞生于 2013 年初，基于 Google 公司的 Go 语言进行实现。可以通过虚拟化方式，为应用提供可运行的容器。基于这种方式，可更快地打包、测试以及部署应用程序。

#Docker核心对象

镜像（Image）
Docker 镜像是一个特殊的文件系统（https://hub.docker.com/），除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。例如JDK镜像、Centos镜像、MySQL镜像等，可以暂时先将其理解为一个安装程序。

容器（Container）
Docker容器可以将其理解为一个运行镜像的载体，镜像（Image）和容器（Container）的关系，就像是光盘和光驱。容器基于镜像创建、启动，然后运行镜像的中的文件。

#Docker 应用架构分析

#架构图

Docker 是一种Client/Server架构的应用程序，如图所示（参考docker 官网https://docs.docker.com/get-started/overview/）

 

其中：

Docker Host是我们的docker宿主机（就是安装了docker的操作系统）
Registry是docker拉取镜像的远程仓库,提供大量的镜像供下载，下载完成之后保存在Images中
Docker Daemon是docker的服务线程，处理Docker客户端命令。
Images 是Docker本地的镜像仓库，可以通过docker images查看镜像文件

#Docker运行机制
#docker pull 执行过程：

1）客户端将指令发送给docker daemon
2）docker daemon 先检查本地images中有没有相关的镜像
3）如果本地没有相关的镜像，则向镜像服务器请求，将远程镜像下载到本地

#docker run 执行过程：

1.检查本地是否存在指定的镜像，不存在就从公有仓库下载
2.利用镜像创建并启动一个容器
3.分配一个文件系(简版linux系统)，并在只读的镜像层外面挂载一层可读写层
4.从宿主机配置的网桥接口中桥接一个虚拟接口到容器中去
5.从地址池配置一个 ip 地址给容器
6.执行用户指定的应用程序
 

 #Docker指令

先在虚拟机系统中右键启动终端 通过ifconfig指令查看网络

通过MobaXterm工具链接虚拟机系统

卸载Docker

假如已经有docker,可以通过入戏指令卸载Docker

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

 在线安装Docker

第一步:安装一组工具  sudo yum install -y yum-utils

第二步：设置 yum 仓库地址

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

sudo yum-config-manager \
    --add-repo \
     http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

第三步：更新 yum 缓存  sudo yum makecache fast  #yum 是包管理器

第四步：安装新版 docker    sudo yum install -y docker-ce docker-ce-cli containerd.io

#离线安装Docker

第一步：下载docker离线包

https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz

说明，也可以从https://download.docker.com/linux/static/stable/网址下载指定版本

第二步：下载离线安装工具  https://github.com/Jrohy/docker-install/

 说明，将下载好的这个工具解压

第三步：将下载好的资源放在一个目录，例如

在linux环境下，创建/root/setup/docker目录，然后拷贝下载好的资源到此目录（可通过MobaXterm工具直接上传到linux目录）

第四步：执行安装操作

# 进入/root/setup/docker 文件夹    cd /root/setup/docker 

#为 install.sh添加执行权限  chmod +x install.sh 

#安装    ./install.sh -f docker-20.10.6.tgz

第五：安装成功以后，检查安装状态 docker info

 #Docker服务基本操作

启动Docker服务  systemctl start docker

查看Docker状态 systemctl status docker

设置Docker开机自启  systemctl enable docker

禁用Docker开机自启  systemctl disable docker

重新启动Docker服务  systemctl restart docker

查看Docker信息  docker info

查看Docker中具体key的信息  docker info | grep 'Docker Root Dir:'

停止Docker服务  systemctl stop docker

Docker镜像加速

由于国内网络问题，需要配置加速器来加速。修改配置文件 /etc/docker/daemon.json

下面命令直接生成文件 daemon.json

cat < /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF

说明：在执行如上指令时，保证你的登录用户为root管理员用户,并且设置好以后重启docker服务

Docker镜像操作

下载镜像 docker pull 镜像名

浏览镜像文件  docker images

查看镜像详情  docker inspect 镜像名或镜像id

查看镜像历史 docker history 镜像名

删除镜像文件  docker image rm 镜像名或镜像id

导入镜像操作  docker load < xxxx.tar.gz (在.tar.gz文件所在目录执行)

保存镜像文件(导出)   docker save 镜像名 | gzip > xxxx.tar.gz

构建镜像   docker build -t sentinel:8 .   不要丢掉这里的点

运行镜像文件 docker run镜像名或镜像id

创建并启动容器  docker run -it xxxx bash

其中：
1)xxxx - 镜像名, 或 image id 的前几位，
2)-it 这是两个参数(-i表示交互式操作， -t 表示终端)
3) bash 表示进入操作终端，基于交互式进行相关操作（例如执行linux相关指令）

查看docker运行中的容器  docker ps

查看docker运行中的所有容器 docker ps -a  (-a表示全部all)

查看容器日志信息  docker container logs 镜像id 重点!!!没有启动需要此指令看错误日志

停止运行的容器 docker stop 容器id

重新启动容器  docker restart 容器id

开启容器  docker start 容器id

进入指定容器  docker exec -it 容器id bash 

退出容器  exit

删除容器   docker container rm 容器id

清除所有终止状态的容器  docker container prune

#Docker数据管理 

在容器中管理数据主要有两种方式：

挂载主机目录 (Bind mounts)-最常用 (docker run -v 宿主机目录:容器目录)

数据卷（Volumes）

#数据卷

数据卷是一个可供一个或多个容器使用的特殊目录，可以在容器之间共享和重用，默认会一直存在，即使容器被删除。

#数据卷操作

创建数据卷  docker volume create container-vol

查看所有数据卷  docker volume ls

查看指定数据卷信息  docker volume inspect container-vol

启动挂载数据卷的容器  docker run -it --mount source=container-vol,target=/root centos:7 bash

                                    简写  docker run -it -v container-vol:/root centos:7 bash

-v container-vol:/root 把数据卷 container-vol 挂载到容器的 /root 目录

删除数据卷  docker volume rm container-vol

清理无主数据卷  docker volume prune

挂载主机目录 docker run -it -v /usr/app:/opt/app centos:7 bash

其中：
1)/usr/app：为宿主机目录
2)/opt/app: 为启动容器的一个目录
3)-v 用于指定挂载目录，如果本地目录(宿主机目录)不存在， Docker 会自动为你按照挂载目录进行目录的创建

 查看挂在目录信息  docker inspect 容器id

#Dockerfile及镜像制作实践

Dockerfile 是一个用来构建镜像的文本文件,文本内容包含了一条条构建镜像所需的指令和说明。我们通常会基于此文件创建docker镜像。

#准备工作

centos:7镜像 (所有的镜像文件创建时都需要有一个空的centos镜像，就类似通过一个空的光盘或u盘创建一个系统启动盘是一样的)

jdk压缩包 jdk-8u51-linux-x64.tar.gz(可以从官网去下载:oracle.org)，基于此压缩包，制作jdk镜像。

#Dockfile文件

在创建新的镜像时都需要有一个Dockerfile文件(文件名一定要注意大小写)，这个文件要与你的资源放在一起(例如你下载的jdk)，我们可以通过linux系统中的touch指令创建此文件（touch Dockerfile）

现在，以centos7为基础，构建oracle jdk8的镜像，首先通过vim打开Dockerfile，这个文件不存在会自动创建。然后进入编辑模式(按i字母)，在编辑模式下可以拷贝如下语句（自己手动写也可以，但确保写的单词正确，大小写，空格）。
第一步：编写FROM语句(关键字一定要大写，例如FROM不能写小写) FROM centos:7

第二步：通过ADD命令将宿主机中的压缩包传入镜像容器中的指定目录,并同时解压缩

ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker

第三步：设置环境变量(通过ENV关键字实现，目录启动容器中的目录)

ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \ PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH

第四步：指定命令行操作(所有指令与后面内容要有空格)  CMD [‘bash’]

完整示例如下：（注意关键字与后面内容之间的空格，可以将如下完成示例拷贝Dockerfile文件，但是一定要注意你的jdk名字是什么）

FROM centos:7
ADD jdk-8u51-linux-x64.tar.gz /usr/local/docker
ENV JAVA_HOME=/usr/local/docker/jdk1.8.0_51 \
    PATH=/usr/local/docker/jdk1.8.0_51/bin:$PATH
CMD ['bash']

使用Docker 构建镜像(在Docker所在目录执行docker指令)

docker build -t jdk:8 .  不要丢掉这里的点,-t表示镜像标识(镜像名),是tag单词的缩写.

运行镜像文件  docker run -it jdk:8 bash

查看环境变量  echo $PATH

如何通过镜像运行一个web服务,例如sentinel

第一步：将sentinel拷贝宿主机指定目录，例如/root/servers目录(servers目录不存在可以自己创建)。

第二步：启动镜像容器，通过java执行运行web服务

基于jdk:8镜像启动运行sentinel服务(服务启动后可在宿主机通过localhost:8180进行访问)

docker run -d -p 8180:8080 --name sentinel \

-v /root/servers:/usr/sca \

jdk:8 java -jar /usr/sca/sentinel-dashboard-1.8.0.jar

 #制作Sentinel镜像

第一步：定义Dockerfile文件,同时将jdk,sentinel也要和这个文件放在同一个目录

FROM centos:7
ADD jdk-8u51-linux-x64.tar.gz  /usr/local/
ADD sentinel-dashboard-1.8.0.jar  /usr/local/
ENV JAVA_HOME=/usr/local/jdk1.8.0_51 \
    PATH=/usr/local/jdk1.8.0_51/bin:$PATH
EXPOSE 8080
ENTRYPOINT ["java","-jar","/usr/local/sentinel-dashboard-1.8.0.jar"]

第二步:使用 Dockerfile 构建镜像(在Dockerfile所在目录执行docker指令)

docker build -t sentinel:8 . #不要丢掉这里的点

第三步：运行sentinel容器  docker run -d -p 8180:8080 sentinel:8

假如我们要做目录的挂载,保存容器中日志,可参考如下方式:

docker run -d -p 8180:8080 --name sentinel \

-v /usr/local/docker/sentinel/logs:/root/logs/csp sentinel:8

第四步:查看sentinel容器  docker ps

假如看不到容器,可以查看容器状态 "docker container logs 容器id"

第五步:访问sentinel服务

访问时你的ip地址应该为宿主机的ip地址,端口号为宿主机的端口号.例如
192.168.126.128:8180

#安装MySql数据库

#安装步骤

第一步：在hub.docker.com上搜索mysql镜像

 第二步：拉取指定版本的mysql，也可以指定拉取版本，例如： docker pull mysql:8.0.23

第三步：检查mysql镜像  docker images

第四步：启动运行mysql镜像 (docker run 用于启动一个容器)

sudo docker run -p 3306:3306 --name mysql \
-v /usr/local/docker/mysql/mysql-files:/var/lib/mysql-files \
-v /usr/local/docker/mysql/conf:/etc/mysql \
-v /usr/local/docker/mysql/logs:/var/log/mysql \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:8.0.23

假如安装过程中失败了，则可通过docker ps -a 查看以前的容器，假如已存在，则通过docker rm 镜像id 删除再重新安装即可

设置mysql开机自启动（可选） docker update mysql --restart=always

#安装Redis数据库

#安装步骤

第一步：下载镜像文件  docker pull redis

第二步：准备配置文件  mkdir -p /usr/local/docker/redis01/conf

在配置文件录下创建redis.conf配置文件(这个文件一定要创建，否在我们进行目录挂载时默认生成的是一个目录)

touch /usr/local/docker/redis01/conf/redis.conf

第三步：创建redis实例并启动

sudo docker run -p 6379:6379 --name redis01 \
-v /usr/local/docker/redis01/data:/data \
-v /usr/local/docker/redis01/conf/redis.conf:/etc/redis/redis.conf \
-d redis redis-server /etc/redis/redis.conf 

第四步：查看正在运行的进程  docker ps

#访问redis服务器

第一步：控制台直接连接redis测试  docker exec -it redis01 bash

第二步：检测redis 版本  redis-server -v 或者 redis-cli -v

第三步：登录redis(默认不需要密码)  redis-cli

或者直接将上面的两个步骤合为一个步骤执行也可以，指令如下： docker exec -it redis01 redis-cli

#安装Ngnix代理

第一步：拉取ngnix镜像 （从这里hub.docker.com去查找）  docker pull nginx

第二步：查看images镜像  docker images

第三步:创建数据卷(这个对象会在宿主机直接创建一个目录)  docker volume create nginx-vol

说明:查看数据卷对应的宿主机目录,可以通过如下指令:  docker inspect nginx-vol

第四步：启动nginx服务  docker run --name nginx -p 80:80 -v nginx-vol:/etc/nginx -d nginx

其中:/etc/nginx 为nginx容器启动时,nginx镜像文件默认的解压目录

说明:假如以后想修改nginx配置,可以直接去nginx-vol数据卷对应的目录去修改.

#安装Ngnix组件

#安装步骤

第一步安装nacos (hub.docker.com)  docker pull nacos/nacos-server:1.4.1

第二步： mysql中执行nacos的sql脚本文件 

1)将此文件nacos-mysql.sql(这个文件可从code服务器下载)拷贝到mysql容器的宿主机对应的挂载目录(可通过docker inspect mysql查看你mysql的挂载目录)

2)在linux环境下启动并登录mysql

进入mysql容器(前提是mysql已启动)   docker exec -it mysql bash

登录mysql   mysql -uroot -p

3)通过source指令运行容器目录下的sql文件   source /容器目录/nacos-mysql.sql

第三步：创建并启动nacos容器

docker run  \
-e TZ="Asia/Shanghai" \
-e MODE=standalone \
-e SPRING_DATASOURCE_PLATFORM=mysql \
-e MYSQL_DATABASE_NUM=1 \
-e MYSQL_SERVICE_HOST=xxx.xxx.xxx.xxx \
-e MYSQL_SERVICE_PORT=3306 \
-e MYSQL_SERVICE_USER=xxxx \                   
-e MYSQL_SERVICE_PASSWORD=xxxx \
-e MYSQL_SERVICE_DB_NAME=nacos_config \
-p 8848:8848 \
--name nacos \
--restart=always \
-d nacos/nacos-server:1.4.1

参数说明

单节点模式
MODE=standalone
数据库地址
MYSQL_SERVICE_HOST
数据库用户名
MYSQL_SERVICE_USER
数据库密码
MYSQL_SERVICE_PASSWORD
需连接的数据库名称
MYSQL_SERVICE_DB_NAME
端口映射
-p 8848:8848
任意时候重启容器，开机就能自动启动容器（需设置docker为开机自启） --restart=always

第四步：检查nacos服务  docker ps

假如启动失败，检查启动日志，例如：   docker container logs nacos

其中，nacos的启动日志在/home/nacos/logs/start.out文件中

访问nacos服务  启动nacos，然后在windows中输入http://ip:port/nacos方式进行访问测试

#Docker 容器互联

Docker 中存在多个容器时，容器与容器之间经常需要进行通讯，例如nacos访问mysql，redis集群中各个节点之间的通讯。

Docker 中容器与容器之间进行通讯的解决方案一般有两种：
第一种：两个容器通过宿主机进行通讯（容器中的端口会映射到宿主机上）
第二种：两个容器之间直接通过虚拟网络进行连接,但是需要我们在docker中创建网络。

#初始化网络

新建网络   docker network create -d bridge t-net    #t-net为自己起的网络名称

其中，-d driver,网络类型，默认 bridge。 创建好这个网络以后，在网落上添加容器，容器就可以通讯了

#查看网络信息

列出所有网络   docker network ls

查看网络信息   docker inspect 67d    #67d 为创建的网络id

#实现容器互联

#创建容器

打开终端，基于centos:7这个镜像启动容器，并加入到t-net这个网络

docker run -it --name app1 --network t-net centos:7

新开终端执行，基于centos:7这个镜像再启动容器，同时也加入到t-net网络

docker run -it --name app2 --network t-net centos:7

#测试网络互通

在两个终端中分别执行   ping app1        ping app2