【other】docker相关基础介绍

一、docker基础介绍

1.1 docker 是什么？

• docker 是一个开源的应用容器引擎
• docker 诞生于2013年，基于Go语言实现，
• docker可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，现在也支持Windows 和 Mac OS
• 容器是完全使用沙箱机制，相互隔离
• 容器性能开销极低

1.2 docker 安装

1. 先卸载旧版本的docke
sudo apt-get remove docker docker-engine docker.io
2. 更新一下apt-get源
sudo apt-get update
3. 安装GPG证书
#别忘了最后的“-”
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
4. 写入软件源信息
sudo add-apt-repository "deb [arch=amd64] http://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"
5. 列出可用版本
sudo apt-cache madison docker-ce
6. 更新并安装 Docker-CE
sudo apt-get update
sudo apt-get install docker-ce=5:23.0.5-1~ubuntu.20.04~focal
sudo apt-get install docker-ce=5:24.0.9-1~ubuntu.22.04~jammy
7. 开启docker服务，查看docker状态
sudo service docker start
sudo service docker status
systemctl restart docker
8.使用docker的命令，查看现有镜像和正在运行的容器
docker images
docker ps
# docker compose安装
curl -L "https://github.com/docker/compose/releases/download/1.29.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"


sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

docker -v

2、换源

[root@localhost henryhzy]# vim /etc/docker/daemon.json  # 创建或修改 /etc/docker/daemon.json 文件，修改为如下形式
{
    "registry-mirrors" : [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com",
    "https://cr.console.aliyun.com/"
  ]
}
$ systemctl daemon-reload
$ systemctl restart docker
$ docker info

1.3 Docker 架构

• 镜像（Image）：Docker镜像（Image），就相当于是一个root文件系统。比如官方镜像 ubuntu:16.04就包含了完整的一套Ubuntu16.04最小系统的root文件系统
• 容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等
• 仓库（Repository）：仓库可以看成一个代码控制中心，用来保存镜像

拉取镜像下来，相当于拉了这个系统，然后启动容器，就是运行这个镜像，一个镜像可以启动多个容器，容器必须要基与镜像去启动。

仓库，就比如说docker官方仓库，你也可以私人新建一个仓库。

1.4 docker 内的网络通信，四种网络模式

Docker 网络模式	配置	说明
host 模式	-net=host	主机网络模式，容器和书主机共享Network name
container模式	-net=container=NAME_or_ID	容器网络模式，容器和另外一个容器共享Network namespace。kubernetes中pod就是多个容器共享一个Network namespace。
none 模式	-net=none	容器有独立的Network namespace,但病灭有对齐进行任何网络设置，如分配vetn pair和网桥链接 ip等
bridge 模式 （桥）默认	-net=bridge	桥接网络模式 这个是默认模式，

1. 桥接网络模式（Bridge Network Mode）：—-比较通用比较常规的方式，默认使用

   • 默认情况下，Docker容器使用桥接网络模式。
   • 在桥接网络模式下，Docker守护进程会为每个容器创建一个虚拟网桥，并将容器连接到该网桥上。
   • 容器可以通过桥接网络相互通信，也可以与宿主机进行通信。
   • 桥接网络模式适用于多个容器需要在相同的网络中进行通信的场景，比如应用程序的分布式部署。

2. 主机网络模式（Host Network Mode）：—-与主机同网，性能高

   • 在主机网络模式下，容器与宿主机共享相同的网络命名空间，容器直接使用宿主机的网络栈。
   • 容器与宿主机之间没有网络隔离，容器的网络操作与宿主机一致。
   • 主机网络模式适用于对网络性能要求较高的场景，比如需要容器与宿主机共享网络端口或者需要最大化网络吞吐量的应用。

3. 容器网络模式（Container Network Mode）：—–更适合适合容器之间通讯

   • 在容器网络模式下，多个容器可以共享同一个网络栈。
   • 容器可以通过容器名称进行通信，而无需使用IP地址。
   • 容器网络模式适用于需要在多个容器之间建立专用网络的场景，比如多个应用容器需要与数据库容器进行通信。

4. 无网络模式（None Network Mode）：

   • 在无网络模式下，容器没有任何网络连接。
   • 容器无法通过网络访问外部系统，也无法从外部系统访问容器。
   • 无网络模式适用于对网络完全隔离的场景，比如安全性要求高的容器环境。

这些网络模式提供了不同的网络配置选项，可以根据具体的应用需求选择合适的网络模式。通过适当选择网络模式，可以满足容器之间的通信需求，提供网络隔离和安全性，并优化网络性能。

二、Docker 命令

2.1 Docker 服务相关命令

• 启动docker 服务：

  systemctl start docker

• 停止docker 服务：

  systemctl stop docker

• 重启docker 服务：

  systemctl restart docker

• 查看docker 服务状态：

  systemctl status docker

• 设置开机启动docker：

  systemctl enable docker

• 其他docker 命令

  docker version
  docker info
  docker --help
  docker pull --help

2.2 Docker 镜像相关命令

• 查看镜像：查看本地所有的镜像

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

• 搜索镜像：从网络中查找需要的镜像

  docker search 镜像名称

• 拉取镜像：从Docker 仓库下载镜像到本地，镜像名称格式为名称:版本号，如果版本号不指定则是最新的版本。如果不知道镜像版本，可以去docker hub 搜索对应镜像查看

  docker pull 镜像名称

• 删除镜像：删除本地镜像

  docker rmi 镜像id/名称号:版本号 #删除指定本地镜像
  docker rmi 'docker images -q' #删除所有本地镜像

• 保存镜像：将我们的镜像 保存为tar 压缩文件 这样方便镜像转移和保存 ,然后 可以在任何一台安装了docker的服务器上 加载这个镜像

  docker save 镜像名/镜像ID -o 镜像保存在哪个位置与名字
  docker save tomcat -o /myimg.tar
  # 加载镜像
  docker load -i 镜像保存文件位置

2.3 Docker 容器相关命令

• 查看容器

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

• 创建并启动容器

  docker run 参数 版本:版本号 </bin/bash>#默认为/bin/bash

  • 参数说明：

    • -i：保持容器运行。通常与-t同时使用。加入it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭
    • -t：为容器重新分配一个伪输入终端，通常与-i同时使用
    • -d：以守护（后台）模式运行容器。创建一个容器在后台运行，需要使用docker exec进入容器docker exec -it c2 /bin/bash。退出后，容器不会关闭
    • -it创建的容器一般称为交互式容器；-id创建的容器一般称为守护式容器
    • --name：为创建的容器命名

• 进入容器

  docker exec 参数 #退出容器，容器不会关闭
  docker exec -it <容器名称或 ID> /bin/bash

• 停止容器

  docker stop 容器名称 

• 启动容器

  docker start 容器名称

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

  docker rm 容器名称

• 查看容器信息

  docker inspect 容器名称

• 查看容器日志-这个很有用

  docker logs 容器名称

三、 Docker 容器的数据卷

3.1 数据卷概念及作用

试着想一下：

• Docker 容器删除后，在容器中产生的数据还在吗？—是持久化的存储吗？
• Docker 容器和外部机器可以交换文件吗？ ——–容器与外部通讯 ？
• 容器之间想要进行数据交互？————容器与容器之间通讯 ？

这里就有一个数据卷的概念了：

• 数据卷是宿主机（运行的物理设备）中的一个目录或文件
• 当容器目录和数据卷目录绑定后，对方的修改会立即同步——绑定本机对应目录
• 一个数据卷可以被多个容器同时挂载———一个目录映射多个容器
• 一个容器也可以被挂载多个数据卷———-一个容器映射多个目录

数据卷的作用就出来了：

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

3.2 配置数据卷

• 创建启动容器时，使用-v参数 设置数据卷

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

  • -v 就是 -Volumes 卷的意思

• 注意事项：

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

3.3 配置数据卷容器

​ 多容器进行数据交换：

1. 多个容器挂载同一个数据卷
2. 数据卷容器

​ 配置数据卷容器：

1. 创建启动c3数据卷容器，使用-v参数 设置数据卷

   docker run -it --name=c3 -v /volume centos:7 /bin/bash

2. 创建启动c1 c2容器，使用--volumes-from参数 设置数据卷

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

四、Docker 应用部署

4.1 MySQL部署

4.1.1案例：需求

• 在Docker 容器中部署MySQL，并通过外部MySQL 客户端操作MySQL Server

4.1.2 案例：实现

1. 搜索mysql镜像
2. 拉取mysql镜像
3. 创建容器
4. 操作容器中的mysql

4.1.3 问题及解决方案

• 容器内的网络服务和外部机器不能直接通信
• 外部机器和宿主机可以直接通信
• 宿主机和容器可以直接通信
• 当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的端口，从而间接访问容器的服务
• 这种操作称为：端口映射

4.1.4 部署MySQL

1. 搜索mysql镜像

   docker search mysql

2. 拉取mysql镜像

   docker pull mysql:5.6

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

   # 在/root目录下创建mysql目录用于存储mysql数据信息
   mkdir ~/mysql
   cd ~/mysql

   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 用户密码

4. 使用外部机器访问MySQL

5. 进入mysql容器创建数据库

docker exec -it 容器id:cecb37dc3872 /bin/bash
# 进入mysql
root@cecb37dc3872:/# mysql -u root -p
#输入密码后进入了
mysql> CREATE DATABASE kinit; # # 创建数据库
Query OK, 1 row affected (0.00 sec)

# 如果你想为 "kinit" 数据库设置一个默认字符集和排序规则，你可以使用以下命令：
CREATE DATABASE kinit CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;# 这将创建一个使用 UTF-8 编码的数据库，并使用适当的排序规则
# 确认数据库是否成功创建，你可以使用以下命令列出所有数据库：
SHOW DATABASES;
mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| kinit              |
| mysql              |
| performance_schema |
+--------------------+
4 rows in set (0.00 sec)

4.2 Tomcat部署

1. 搜索Tomcat 镜像

   docker search tomcat

2. 拉取mysql镜像

   docker pull tomcat

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

   #在/root目录下创建tomcat目录用于存放tomcat数据信息
   mkdir ~/tomcat
   cd ~/tomcat

   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

4. 最后使用外部机器访问tomcat

4.3 Nginx部署

1. 搜索Nginx 镜像

   docker search nginx

2. 拉取mysql镜像

   docker pull nginx

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

   #在/root目录下创建nginx目录用于存储nginx数据信息
   mkdir ~/nginx
   cd ~/nginx
   mkdir conf
   cd conf
   #在~/nginx/conf/下创建nginx.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;
   }

   docker -run -id --name=c_nginx \
   -p 80:800 \
   -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:800：将容器的80端口映射到宿主机的80端口
     • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的/conf/nginx.conf挂载到容器的:/etc/nginx/nginx.conf配置目录
     • -v $PWD/html:/usr/share/nginx/html：将主机当前目录挂载到容器的/val/log/nginx日志目录

4. 使用外部机器访问nginx

4.4 Redis部署

1. 搜索Redis 镜像

   docker search redis

2. 拉取Redis 镜像

   docker pull redis:5.0

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

   # 创建 redis 配置存放目录
   mkdir -p redis_kinit/conf && chmod 777 redis_kinit/conf
   
   # 创建 redis 数据存放目录
   mkdir -p redis_kinit/data && chmod 777 redis_kinit/data
   # 启动
   docker run -id --name=c_redis -p 6379:6379 redis:5.0
   
   
   # 要先去官网下载对应的配置文件 https://raw.githubusercontent.com/redis/redis/7.0/redis.conf
   
   # 自定义启动 redis
   docker run -d -p 6379:6379 \
   --name redis_kinit \
   --restart=always \
   -v $PWD/redis_kinit/data:/data \
   -v $PWD/redis_kinit/conf/redis.conf:/etc/redis/redis.conf \
   redis:7.0.4 \
   redis-server /etc/redis/redis.conf \
   --appendonly yes \
   --requirepass 123456
   
   
   docker run -itd -p 6378:6379 \
   --name redis_kinit2 \
   --restart=always \
   -v $PWD/data:/data \
   -v $PWD/conf/redis.conf:/etc/redis/redis.conf \
   redis:7.0.4 \

4. 使用外部机器连接redis

   redis-cli.exe -h 192.168.187.129 -p 6379
   # 验证一下是否部署成功
   docker exec -it <容器名称或ID> redis-cli
   docker exec -it 73f59ae7be56 redis-cli
   然后如果提示(error) NOAUTH Authentication required.
   就AUTH验证你的密码，再试试
   # 输入ping 
   # 看会不会返回 pong

4.5 mongo部署

1. 搜索Redis 镜像

   docker search mongo

2. 拉取Redis 镜像

   docker pull mongo

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

   # 创建 mongo 数据存放目录
   mkdir -p /mongo_kinit/data && chmod 777 /mongo_kinit/data
   
   # 启动
   docker run \
   --name kinit_mongo \
   -p 27017:27017  \
   -v $PWD/data:/data/db \
   -d mongo \
   --auth
   
   # 进入
   $ docker exec -it mongo mongosh admin
   # 创建一个名为 admin，密码为 123456 的用户。
   >  db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'},"readWriteAnyDatabase"]});
   # 尝试使用上面创建的用户信息进行连接。
   > db.auth('admin', '123456')
   # 创建
   use kinit # 创建数据库
   db.createUser({ user: 'admin', pwd: '123456', roles: [ { role: "userAdminAnyDatabase", db: "admin" } ] });
   db.auth('admin', '011023') # 尝试使用上面创建的用户信息进行连接。
   exit # 创建成功后可退出
   
   db.createUser({ user: 'kinit', pwd: '123456', roles: [ { role: "readWrite", db: "kinit" } ] })
   db.auth("kinit","123456") # 验证是否创建成功
   exit
   mongodb://admin:123456@127.0.0.1:27017

五、docker file（后续有空补充）

5.1 Docker 镜像原理

​ 思考：

• Docker 镜像的本质是什么？
  • 是一个分层的文件系统
• Docker 中一个CentOS 镜像为什么只有200MB，而一个CentOS 操作系统的iso 文件要几个G？
  • CentOS的iso镜像文件包含bootfs和rootfs，而Docker的CentOS镜像复用操作系统的bootfs，只有rootfs和其他镜像层
• Docker 中一个Tomcat 镜像为什么有500MB，而一个Tomcat 安装包只有70多MB？
  • 由于Docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所以整个对外暴露的tomcat镜像大小500多MB

操作系统组成部分：

• 进程调度子系统
• 进程通信子系统
• 内存管理子系统
• 设备管理子系统
• 文件管理子系统
• 网络通信子系统
• 作业控制子系统

Linux文件系统由bootfs 和rootfs 两部分组成

• bootfs：包含bootloader（引导加载程序）和kernel（内核）
• rootfs：root文件系统，包含的就是典型的Linux 系统中的/dev、/proc、/bin等标准目录和文件
• 不同的Linux 发行版，bootfs 基本一样，而rootfs 不同，如ubuntu，CentOS等

Docker 镜像原理：

• Docker 镜像是由特殊的文件系统叠加而成
• 最低端是bootfs，并使用宿主机的bootfs
• 第二层是root 文件系统rootfs ，称为base iamge
• 然后再往上可以叠加其他的镜像文件
• 统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层的存在，在用户的角度看来，只存在一个文件系统
• 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像
• 当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器

镜像制作：

• 容器转为镜像

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

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

  docker load -i 压缩文件名称

5.2 Dockerfile 概念及作用

Dockerfile 概念

• Dockerfile 是一个文本文件
• 包含了一条条的指令
• 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• 对于开发人员，可以为开发团队提供一个完全一致的开发环境
• 对于测试人员，可以直接拿开发时所构建的镜像或者通过Dockerfile 文件构建一个新的镜像开始工作了
• 对于运维人员，在部署时，可以实现应用的无缝移植

5.3 Dockerfile 关键字

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于哪个images构建
MAINTAINER	作者信息	用来标明这个dockerfile 谁写的
LABEL	标签	用来指明dockerfile 的标签，可以使用Label代替Maintainer 最终都是在docker image基本信息中嗯可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式：RUN command 或者 RUN ["command","param1","param2"]
CMD	容器启动命令	提供启动容器时候的默认命令和ENTRYPOINT配合使用。格式：CMD command param1 param2或者CMD ["command","param1","param2"]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build 的时候复制文件到image中
ADD	添加文件	build 的时候添加文件到iamge 中，不仅仅局限于当前build 上下文 可以来源于远程服务
ENV	环境变量	指定build 时候的环境变量 可以在启动容器的时候 通过-e覆盖 格式：ENV name = value
ARG	构建参数	构建参数 只在构建的时候使用参时 如果有ENV 那么ENV 的相同名字的值始终覆盖ARG 的值
VOLUME	定义外部可以挂载的数据卷	指定build 的image 那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用-v绑定 格式：VOLUME ["目录"]
EXPOSE	暴露端口	定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式：EXPOSE 8080或者EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录 如果没有创建则自动创建 如果指定/使用是绝对地址 如果不是/开头那么实在上一条workdir 的路径的相对路径
USER	指定执行用户	指定build 或者启动的时候 用户 在RUN CMD ENTRYPOINT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康测试的命令 基本上没有 因为很多时候 应用本身由健康监测机制
ONBUILD	触发器	当存在ONBUILD 关键字的镜像作为基础镜像的时候 当执行FROM 完成之后 会执行ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL	发送信息量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

5.4 案例

5.4.1 案例一

需求：

​ 自定义CentOS7镜像。要求：

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

实现步骤：

1. 定义父镜像：FROM centos:7
2. 定义作者信息：MAINTAINER crisp077 <www.crisp077.xyz>
3. 执行安装vim命令：RUN yum install -y vim
4. 定义默认的工作目录：WORKDIR /usr
5. 定义容器启动执行的命令：CMD /bin/bash

创建使用dockerfile的镜像：

docker build -f ./centos_docker -t crisp_centos:1 .

5.4.2 案例二

需求：

​ 定义dockerfile，发布springboot 项目

实现步骤：

1. 定义父镜像：FROM java:8
2. 定义作者信息：MAINTAINER crisp077 <www.crisp077.xyz>
3. 将jar包添加到容器：ADD springboot.jar app.jar
4. 定义容器启动执行的命令：CMD java -jar app.jar
5. 通过dockerfile 构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本

六、docker compose （简单介绍）

6.1 服务编排的概念

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

• 要从Dockerfile build image 或者去 dockerhub 拉取image
• 要创建多个container
• 要管理这些container（启动停止删除）

服务编排：

​ 按照一定的业务规则批量管理容器

6.2 Dockers Compose 概述

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

1. 利用 Dockerfile 定义运行环境镜像
2. 使用 docker-compose.yml 定义组成应用的各服务
3. 运行 docker-compose up 启动应用

6.2.1 安装Docker Compose

#Compose 目前已经完全支持Linux、MAC OS、Windows，在安装Compose之前，需要先安装Docker。下面以编译好的二进制包方式安装在Linux中
curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
#设置文件可执行权限
chmod +x /usr/local/bin/docker-compose
#查看版本信息
docker-compose -version

6.2.2 卸载Docker Compose

#二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

6.3 案例

使用docker compose编排nginx+springboot项目

1. 创建docker-compose目录

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

2. 编写docker-compose.yml文件

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

3. 创建./nginx/conf.d目录

   mkdir -p ./nginx/conf.d

4. 在./nginx/conf.d目录下编写crisp.conf文件

   server {
       listen 80;
       acess_log off;
   
       location / {
           proxy_pass https://app:8080;
       }
   
   }

5. 在~/docker-compose目录下 使用dockers-compose 启动容器

   docker-compose up

6. 测试访问

   http://192.168.187.129/hello

6.4 docker compose介绍【新】

docker compose 最开始是一个插件，后来官方采纳了这个开发者开发的开源插件

1. 用于定义和运行多容器docker 应用程序的工具，它使用YAML文件来配置应用程序的服务、网络和数据卷等组件，并通过一些简单的命令提供一种统一的方式来管理和操作这些容器
2. 多容器应用：Docker Compose适用于构建和管理多容器的应用程序。你可以在同一个Compose文件中定义和管理应用程序中的多个服务，这些服务可以相互通信和协作。
3. 声明式配置：通过使用YAML文件来定义Compose配置，你可以以声明式的方式描述应用程序的结构和配置。这使得配置易于阅读、理解和维护，并且可以轻松地重现整个应用程序环境。
4. 简化的部署和管理：使用Docker Compose，你可以使用一条简单的命令来启动、停止、重启和删除整个应用程序。这使得应用程序的部署和管理变得更加简单和一致。
5. 网络和卷配置：Docker Compose允许你定义应用程序中的网络和卷配置。你可以创建自定义网络，使得Compose中的服务可以相互通信。你还可以定义卷挂载，用于持久化数据或在容器之间共享文件。
6. 扩展和覆盖：Compose配置支持扩展和覆盖，这意味着你可以在不同的环境中使用相同的Compose文件，只需根据需要覆盖某些配置。这使得在开发、测试和生产环境之间切换变得更加容易。

服务定义：使用Docker Compose，你可以定义应用程序中的各个服务。每个服务都可以由一个或多个容器组成，可以设置容器的映像、端口映射、环境变量、卷挂载等配置

简单说就是：将你的某个应用程序所需要的服务，都编排到一个队列上去，通过docker compose来同一管理，这个时候你的这个compose内的容器都会处于同一个bridge桥网络下，

提供了一种简单且一致的方式来组织和操作容器化的应用程序，并使得在不同环境钟部署和运行应用程序变得更加容易

6.1.1 docker compose 相关命令

构建镜像：

docker-compose build
```
这个命令将根据Compose文件中定义的服务构建镜像。如果镜像已经存在，它将跳过构建步骤。

启动容器：

docker-compose up
```
这个命令将使用Compose文件启动定义的服务。如果Compose文件不存在，它将自动构建镜像并启动容器。

启动容器（后台模式）

docker-compose up -d
```
这个命令将以后台模式启动容器，并将输出重定向到终端。

查看Compose服务状态：

docker-compose config
```
这个命令将验证Compose文件的语法并显示解析后的配置。

停止容器：

docker-compose down
```
这个命令将停止并删除Compose文件定义的所有容器、网络和卷。

查看Compose文件配置

docker-compose config
```
这个命令将验证Compose文件的语法并显示解析后的配置。

执行Compose服务命令

docker-compose exec <service_name> <command>
```
这个命令将在指定的服务容器中执行给定的命令。

查看Compose服务日志：

# 查看Compose的服务日志：
docker-compose logs
```
这个命令将显示Compose文件中定义的所有服务的日志输出。
# 查看Compose的实时日志：
docker-compose logs -f
```
这个命令将以实时方式显示Compose文件中定义的所有服务的日志输出。你可以通过按下`Ctrl + C`来停止实时日志输出。
# 查看特定服务的日志
docker-compose logs <service_name>
```
这个命令将显示指定服务的日志输出。你可以替换`<service_name>`为Compose文件中定义的服务名称。

# 查看指定服务的实时日志：
docker-compose logs -f <service_name>
```
这个命令将以实时方式显示指定服务的日志输出。你可以替换`<service_name>`为Compose文件中定义的服务名称。

6.2 Kubernetes(K8S)简单介绍

开发只负责开发（拔掉开发的网线），其他杂七杂八的服务有运维通过K8S统一管理

比如说：开发连接数据库查询数据：只负责127.0.0.1本地连接即可，运维会在路由那里统一配置

6.2.2 Kubernetes介绍

Kubernetes（通常简称为K8s）是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。它提供了一个强大的工具集，用于管理和编排容器化应用程序的各个方面，如部署、扩缩容、负载均衡、服务发现、自愈性等。

以下是网上抄的Kubernetes的一些关键概念和特点：

1. 容器编排：Kubernetes设计用于管理容器化应用程序。它可以自动部署和管理容器，确保它们在集群中正确运行，并根据需要进行扩展和收缩。
2. 高可用性：Kubernetes提供高可用性的架构，通过在集群中的多个节点上运行容器副本，并自动重新调度故障容器，确保应用程序的可用性。
3. 自动化扩缩容：Kubernetes允许根据应用程序的负载情况自动扩展或收缩容器的数量。这样，你可以根据需求快速适应流量变化，提高应用程序的弹性和性能。
4. 服务发现和负载均衡：Kubernetes提供内建的服务发现和负载均衡机制。它可以自动分配稳定的网络地址给容器，并将流量均匀分发到后端服务，确保应用程序的可访问性和高可用性。
5. 状态管理：Kubernetes允许你声明性地定义应用程序的状态和要求。它可以管理应用程序的部署、更新和回滚操作，确保应用程序按照预期运行。
6. 配置和存储管理：Kubernetes提供配置管理和存储管理功能。它可以管理应用程序的配置文件和敏感信息，并支持各种存储选项，如持久卷和分布式存储系统。
7. 健康检查和自愈性：Kubernetes可以对容器进行健康检查，并在容器出现故障时自动重新调度或替换它们。这提高了应用程序的可靠性和稳定性。
8. 插件生态系统：Kubernetes拥有丰富的插件生态系统，支持各种功能和扩展，如日志管理、监控、安全性、网络策略等。

通过使用Kubernetes，你可以更方便地管理和扩展容器化应用程序，提高应用程序的可靠性和弹性。它提供了一个统一的平台，用于自动化管理容器的各个方面，并支持在多云、混合云和本地环境中的部署。+

七、Docker 私有仓库【未完待续】

………………