简单学习 --＞ Docker容器

结构演进

八大架构

1. 单机架构...

2. 主从分离架构: 读和写分离, 写(主数据库) , 读(从数据库) , 多个数据库, 当主数据挂了,从数据库也可以临时上 (缺点: 某个热点数据,频繁读写,也会造成用户访问性能下降)

3. 冷热分离架构 : 比读写分离,多了一个缓存数据存储机制(能读/写)(主流:Redis) , 当请求过来先在缓存数据库进行访问/写入 , 如果不在缓存数据里,在从 主从数据库里访问 ;(这时候热点数据,直接存放在缓存里, 直接就从缓存里拿,不需要在主从数据库里进行读取操作)

缺点: 当数据越来越多, 数据库里进行读取操作消耗也越来越大;

4. 垂直分库架构: 对数据进行分库分表 , 数据进行分布式数据库, (一个总数据库, 拆分成多个模块的数据库; 当一个数据表里数据多,也可以进行分表操作 ) ;例如: 一个总的商品数据库, 分成多个 数据库群集, 有 用户, 商品, 交易...., 当某个表数据多,也进行进一步拆分 ;

缺点: 应用代码整体耦合在一起, 例如: 虽然有多个Tomcat,处理请求, 但是如果我要改一行代码, 需要把这些全部重新部署

5. 微服务架构: 一个大的整体的服务,划分成多个子的微服务,互不干扰,可以独立进行升级部署, 不会因为一个地方修改,而影响整个项目 ;

例如: 一个商城应用, 拆分成多个微服务,如用户服务,商品服务等 互相协作 支撑起整个应用 ;

出现原因: 应用无法轻易扩展,每次更新,都需要重新构建整个系统 ; 系统中的一个问题,可能都会导致整个系统挂了; 整体耦合度高, 所有功能耦合在一起, 让人 难以下手 ; 不灵活: 无法使用不同的技术,构造起应用 ;扩展差, 要扩展一个功能,加多一个微服务即可

缺点: 运维难度高, 故障处理困难 ;

6.容器编排架构: 借助容器化技术(docker), 将应用/服务 可以打包成镜像, 通过容器编排工具(k8s)来进行 动态分发和部署镜像, 服务以容器化的方式运行 ;

出现原有: 多个微服务分的太细了, 多台 部署, 配置麻烦, 容易出错 ;

工作原理: 微服务通过打包成镜像, 安排在容器里部署,

优点:

• 环境一致：镜像打包运行环境，开发、测试、生产环境无差异，告别 "本地能跑线上报错"。
• 一键部署扩容：支持弹性伸缩，流量高峰自动加容器，低峰自动缩容，节省服务器资源。
• 运维简化：不用逐台机器手动配置，编排平台统一管理服务生命周期。
• 高可用自愈：节点或容器故障时，自动重启、迁移容器，保证服务不宕机。
• 资源利用率高：多个微服务容器共享服务器资源，避免单机资源闲置浪费。
• 版本管控便捷：镜像版本可追溯，支持快速回滚，发布出问题能一键恢复。

docker简介

虚拟化,容器化

1. 物理机: 现实的真正的计算机

2. 虚拟化: 用虚拟技术 将计算机 虚拟成多个逻辑计算机

3. 容器化: 是一种虚拟化技术, 对操作系统的虚拟化

为什么要使用虚拟化,容器化

1. 环境标准化: 生成环境和服务器环境是不同的, 使用容器化保证环境相同

2. 资源弹性伸缩: 一台服务器上就可以继续伸缩

3. 差异化环境提供: 这个微服务要10系统, 哪个微服务要20系统, 使用容器化,将物理机分成多个虚拟机, 每个虚拟机用不同的环境

4. 沙箱安全: 虚拟化技术构建的虚拟执行环境, 保证容器里的不安全的影响不会影响到外面的服务器 ;

5. 容器对比虚拟机更轻量,更快速

6. 维护和扩展容易

虚拟机是作为硬件层的虚拟化, 容器是操作系统层的虚拟化

容器虚拟化实现

实现原理

容器虚拟化,是操作系统层的虚拟化,通过 namepace进行 程序隔离,加上cgroups进行资源控制

例如: 有两个容器, 容器a和容器b , a用 windows, b用ubuntu , a和b是隔离开的, 不会互相影响, a有a自己的文件, b有b自己的文件 , 但是他们是共用同一个内核的 ;

容器虚拟化基础NameSpace

NameSpace是linux用来隔离内核资源的方式,a进程只能看到自己的资源, b进程只能看到自己的资源, 这样隔离起来 ;

NameSpace 空间隔离实现

1. dd命令

在linux 上,dd可以用来 读取,转换并输出数据

• 参数
￮ if=文件名：输入文件名，默认为标准输入。即指定源文件。
￮ of=文件名：输出文件名，默认为标准输出。即指定目的文件。
￮ ibs=bytes：一次读入 bytes 个字节，即指定一个块大小为 bytes 个字节。
   obs=bytes：一次输出 bytes 个字节，即指定一个块大小为 bytes 个字节。
   bs=bytes：同时设置读入/输出的块大小为 bytes 个字节。
￮ cbs=bytes：一次转换 bytes 个字节，即指定转换缓冲区大小。
￮ skip=blocks：从输入文件开头跳过 blocks 个块后再开始复制。
￮ seek=blocks：从输出文件开头跳过 blocks 个块后再开始复制。
￮ count=blocks：仅拷贝 blocks 个块，块大小等于 ibs 指定的字节数。
￮ conv=<关键字>，关键字可以有以下 11 种：
   ▪ conversion：用指定的参数转换文件。
   ▪ ascii：转换 ebcdic 为 ascii
   ▪ ebcdic：转换 ascii 为 ebcdic
   ▪ ibm：转换 ascii 为 alternate ebcdic
   ▪ block：把每一行转换为长度为 cbs，不足部分用空格填充
   ▪ unblock：使每一行的长度都为 cbs，不足部分用空格填充
   ▪ lcase：把大写字符转换为小写字符
   ▪ ucase：把小写字符转换为大写字符
   ▪ swap：交换输入的每对字节
   ▪ noerror：出错时不停止
   ▪ notrunc：不截短输出文件
   ▪ sync：将每个输入块填充到 ibs 个字节，不足部分用空（NUL）字符补齐。
￮ --help：显示帮助信息
￮ --version：显示版本信息

2. mkfs 命令

mkfs 用于在 设备上创建 Linux文件系统, 就是格式化 (当然把文件格式化,作为磁盘使用也可以)

• 语法
mkfs [-V] [-t fstype] [fs-options] filesys [blocks]
• 参数
-t fstype：指定要建立何种文件系统；如 ext3，ext4
  filesys ：指定要创建的文件系统对应的设备文件名；
   blocks：指定文件系统的磁盘块数。
-V : 详细显示模式
  fs-options:传递给具体的文件系统的参数

3. df 命令

df命令: 显示Linux系统上的文件系统磁盘使用情况

// 参数
-a  :all ,包括所有具有0Blocks的文件系统
-h  :适合人类可读的方式打印
-H  :和h类似,但是是用 1000为单位,而不是1024
-t  :type,限制列出文件系统的type
-T  :print type 显示文件系统的形式

4.mount 命令

**mount:**命令用于加载文件系统到指定的加载点, 也常用于挂载光盘

(挂载的实质是: 为磁盘添加一个入口(挂载点));例如: win上查一个u,系统会识别出来,我们就可以在文件系统上操作u盘,但Linux不会, 需要我们用 mount命令添加

//常见用法
mount [-l]
mount [-t vfstype] [-o options] device dir
常见参数
-l：显示已加载的文件系统列表；
-t: 加载文件系统类型支持常见系统类型的 ext3,ext4,iso9660,tmpfs,xfs 等,大部分情况
可以不指定，mount 可以自己识别
-o options 主要用来描述设备或档案的挂接方式。
    loop：用来把一个文件当成硬盘分区挂接上系统
     ro：采用只读方式挂接设备
     rw：采用读写方式挂接设备
device: 要挂接(mount)的设备。
dir: 挂载点的目录

5. unshare 命令

unshare : 使用与父程序不共享的名称空间运行程序 ;

• 语法
unshare [options] program [arguments] // 指定某个程序
• 常用参数
-i, --ipc 不共享 IPC 空间
-m, --mount 不共享 Mount 空间
-n, --net 不共享 Net 空间
-p, --pid 不共享 PID 空间
-u, --uts 不共享 UTS 空间
-U, --user 不共享用户
-V, --version 版本查看
--fork 执行 unshare 的进程 fork 一个新的子进程，在子进
程里执行 unshare 传入的参数。
--mount-proc 执行子进程前，将 proc 优先挂载过去 

cgroup(资源控制)

pidstat

用于监控进程的cpu..等各种系统资源的占用情况

stress

压力测试工具,可以对CPU,memory,io,磁盘进行压力测试

Docker

docker 本质是LXC容器的增强版,他本身不是容器,而是容器的易用工具 (用于完成一次封装,到处运行)

Docker和虚拟机的区别

1. Docker磁盘占用小

2. Docker引擎的资源占用小

Docker版本

Docker-ce: 是开源版本

Docker-ee: 是付费版本;

docker 安装步骤

​
sudo mkdir -m 0755 -p /etc/apt/keyrings
//设置下载源
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu focal stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
// 更新
sudo apt-get update
// 下载
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

Docker Registry

docker的镜像仓库: 负责存储, 管理 和 分发镜像 , 提供了认证功能和建立仓库的索引

镜像仓库命令

1.docker login : 登录仓库

登录到一个Docker镜像仓库, 如果没有指定仓库, 默认为官方的dockerHub

docker login [参数] [server地址]   (中括号就是可以有可无的参数)
//参数
-u : 用户名
-p : 密码

2.docker pull : 拉取镜像

从镜像仓库中拉取指定镜像

docker pull [options](参数) [name:tag] (镜像名称:版本)    
                          // 或者是 name@id (名字@版本id)
    参数 : -a 把所有tag都拉取过来

拉取 nginx: 1.23.3

3.docker push : 推送镜像

把本地的镜像上传到镜像仓库, 首先要登录到镜像仓库 ;

docker push [options] name:[tag] (镜像名字:版本)
参数: -a 把所有tag都推送过去

4.docker search : 查找镜像

5.docker logout : 登出仓库

docker的重启

启动        systemctl start docker
​
守护进程重启   sudo systemctl daemon-reload
​
重启docker服务   systemctl restart  docker
​
重启docker服务  sudo service docker restart
​
关闭docker service docker stop
​
关闭docker systemctl stop docker

Docker镜像

Docker image 本质上是一个 只读文件 , 这个文件包含了文件系统, 源码 , 文件 , 依赖 , 工具 等一些 运行 application 所必须的东西 ;

可以把 Docker image理解成一个 模版 , 可以通过模版来实例化很多容器 ; image里面是联合文件系统

Docker 镜像命令

1. docker images

列出本地镜像

docker images [OPTIONS] [REPOSITORY[:TAG]]//查找指定镜像,这里就是 名字:tag的信息
   -a :列出本地所有的镜像（含中间映像层，默认情况下，过滤掉中间映像层）；
   --digests :显示镜像的摘要信息；
   -f :显示满足条件的镜像；
   --format :指定返回值的模板文件；
   --no-trunc :显示完整的镜像信息；
   -q :只显示镜像 ID

2. docker image inspect

查看镜像详细信息

docker images inspect nginx:1.23.3  (也可以根据id)

3. docker tag

标记本地镜像, 可以将其归为 某一个仓库

docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
    
    // docker tag ubuntu:22.04 myregistry.com/myubuntu:22.04
    把 ubuntu镜像 ,改成 其他仓库的 ,这样推送的时候就 可以推送到指定仓库

4. docker rmi

删除本地镜像

docker rmi [OPTIONS] IMAGE [IMAGE...]   // 可以删除多个, 可以根据 name:tag 或 id来删除
    //参数
    -f      :强制删除；  // 正在运行的镜像 是无法删除的, 通过强制删除
    --no-prune :不移除该镜像的过程镜像，默认移除

5. docker build

通过docker file 制作镜像

6. docker save

将制定镜像保存为 tar 归档文件

docker save [OPTIONS] IMAGE [IMAGE...]  // 一样是可以根据名字:tag ,和 id , 也可以一次性 归档多个文件
    //参数
    -o : 输出到哪个文件

7. docker load

导入 使用 "docker save" 所导出的 镜像

docker load [OPTIONS]           //当镜像被 save 输出成归档文件tar时 ,  通过 load 把导出的tar文件给到回来
--input , -i : 指定导入的文件，代替 STDIN。
--quiet , -q : 精简输出信息。

8. docker image inspect

查看镜像的详细信息

9. docker history

查看镜像历史

docker history [OPTIONS] IMAGE   //  显示指定镜像的 '历史'(像盖楼一样,描述这个楼是怎么盖的)
    // 参数
-H , --human :大小和日期采用人容易读的格式展现
--no-trunc :显示全部信息，不要隔断；
-q, --quiet: 只显示镜像 id 信息；

id 创建时间 怎么创建的 大小

10. docker import

从归档文件中创建镜像

docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]
• 关键参数
￮ -c :应用 docker 指令创建镜像；
￮ -m :提交时的说明文字；

11. docker image prune

删除不使用的 镜像

docker image prune [OPTIONS]
    // 参数
-a , --all : 删除全部不使用的镜像；  // 凡是不被容器 使用的镜像 都是不使用的镜像 , 删除镜像操作都是非常危险
--filter filter:指定过滤条件；
-f, --force :不提示是否删除；
​

Docker容器

容器是 镜像运行的实体,是基于镜像创建的可运行的实例 ,本质上 容器是 主机上运行的进程 , 容器有自己独立的空间隔离和资源限制 , 容器内部无法看到主机的进程,环境变量,网络信息等信息 ;(同时因为是进程的形式, 不同容器,也就是不同进程之间是 隔离的)

Docker 容器命令

Nginx

基于http 的 web 服务器的实现 , Nginx可以作为反向代理 进行 负载均衡的 实现

正向代理: 代理客户端, 例如(打游戏,通过vpn , vpn 代理, 访问国外服务器 )

反向代理: : 代理服务端, 即反向代理 "代理"的是服务器, (例如: 我 访问xx网站, 请求发到主服务器a , 但主服务器a负载很大 , 转发到负载小的b服务器去 , 但这个过程 我是不知道的 , 我只知道 我在看xx网站 , 这个往赋值小的地方转发 , 也叫负载均衡)

docker容器命令

1. docker run

创建一个新容器 , 并运行一个命令

// 命令
docker run [OPTIONS] IMAGE [COMMAND] [ARG...]   // [参数] image 镜像名称/镜像id [命令] [命令的参数]
// 参数
￮ -d: 后台运行容器，并返回容器 ID；
￮ -i: 以交互模式运行容器，通常与 -t 同时使用；
￮ -P: 随机端口映射，容器内部端口随机映射到主机的端口
￮ -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
￮ -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；     // -it  bash
￮ --name="nginx-lb": 为容器指定一个名称；
￮ -h "mars": 指定容器的 hostname；
￮ -e username="ritchie": 设置环境变量；
￮ --cpuset-cpus="0-2" or --cpuset-cpus="0,1,2": 绑定容器到指定 CPU 运行；
￮ -m :设置容器使用内存最大值；
￮ --network="bridge": 指定容器的网络连接类型；
￮ --link=[]: 添加链接到另一个容器；
￮ --volume , -v: 绑定一个卷
￮ --rm :shell 退出的时候自动删除容器

run的使用

指定端口

// 让主机8088端口绑定容器的80端口, 容器后台运行 
     docker run -d -p 8088:80 nginx:1.24.0   //  容器运行nginx, 让宿主机 8088端口绑定 容器 的80端口
         //  然后可以在浏览器,访问8088端口,看到 nginx的运行         

指定名字

docker -d --name mynginx1 nginx:1.24.0  // 指定mynginx1名字
    //后面用ps 可以看到创建的名字 , 
    // 通过 docker stop 容器名字 , 就可以停止 容器

2. docker ps

列出容器

docker ps [OPTIONS]
    //参数
￮ -a :显示所有的容器，包括未运行的。
￮ -f :根据条件过滤显示的内容。
￮ --format :指定返回值的模板文件。如 json 或者 table
￮ -l :显示 latest 的容器。
￮ -n :列出最近创建的 n 个容器。
￮ --no-trunc :不截断输出。
￮ -q :静默模式，只显示容器编号。   
    // 返回容器id , 在进行一系列过滤后, 得到一批目标容器的id ,这样又可以根据这一批id ,
    // 继续 执行 其他操作 , 这样实现批量处理容器操作 
￮ -s :显示总的文件大小

3. docker create

创建容器,但不启动他

docker create [OPTIONS] IMAGE [COMMAND] [ARG...]
    
￮-i: 以交互模式运行容器，通常与 -t 同时使用；
￮ -P: 随机端口映射，容器内部端口随机映射到主机的端口
￮ -p: 指定端口映射，格式为：主机(宿主)端口:容器端口
￮ -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
￮ --name="nginx-lb": 为容器指定一个名称；
￮ -h "mars": 指定容器的 hostname；
￮ -e username="ritchie": 设置环境变量；
￮ --cpuset-cpus="0-2" or --cpuset-cpus="0,1,2": 绑定容器到指定 CPU 运行；
￮ -m :设置容器使用内存最大值；
￮ --network="bridge": 指定容器的网络连接类型；
￮ --link=[]: 添加链接到另一个容器；
￮ --volume , -v: 绑定一个卷
￮ --rm :shell 退出的时候自动删除容器
 --restart:自动重启

4. docker logs

查看容器日志

docker logs [OPTIONS] CONTAINER
​
 -f ,--follow: 跟踪日志输出
 --since :显示某个开始时间的所有日志
 -t,--timestamps : 显示时间戳
 -n，--tail :仅列出最新 N 条容器日志

5.docker attach

连接到正在运行的容器

参数
--sig-proxy：是否将所有信号代理，默认是 true，如果设置为 false，退出的
话不会影响容器，否则退出会导致容器退出。

6. docker exec

在容器中 执行命令

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
• 关键参数
￮ -d :分离模式: 在后台运行
￮ -i :即使没有附加也保持 STDIN 打开
￮ -t :分配一个伪终端
￮ -e :设置环境变量
￮ -u,--user :指定用户 "<name|uid>[:<group|gid>]"
￮ -w,--workdir:指定工作目录
• 样例
Shell
#在容器 mynginx 中以交互模式执行 echo:
docker exec -it mynginx echo "Hello bit"
#在容器 mynginx 中以交互模式打开 shell:
docker exec -it mynginx bash
#通过 id 进去，docker ps 可以看到容器 id

7.docker start

启动 停止的容器

docker start [OPTIONS] CONTAINER [CONTAINER...]

8. docker stop

停止运行的容器

docker stop [OPTIONS] CONTAINER [CONTAINER...]
• 关键参数
￮ -s :发送的信号

9. docker restart

重启容器

docker restart [OPTIONS] CONTAINER [CONTAINER...]
• 关键参数
￮ -s :发送信号

10. docker kill

强制退出容器

docker kill [OPTIONS] CONTAINER [CONTAINER...]
• 关键参数
￮ -s :发送的信号
• 注意事项：
￮ Docker stop 发送的是 SIGTERM 信号，docker kill 发送的是 SIGKILL 信号

11. docker top

查看容器中 运行的进程信息 , 支持 ps 命令参数 (支持ps命令参数,可以查看容器的进程)

docker top CONTAINER [ps OPTIONS]

12. docker stats

查看容器资源的使用 , cpu , 内存 ,网络 ,i/o 等 (看这个容器到底使用了多少资源)

docker stats [OPTIONS] [CONTAINER...]
• 关键参数
￮ --all , -a :显示所有的容器，包括未运行的。
￮ --format :指定返回值的模板文件。如 table,json
￮ --no-stream :展示当前状态就直接退出了，不再实时更新。
￮ --no-trunc :不截断输出。
• 返回报文
CONTAINER ID 与 NAME: 容器 ID 与名称。
CPU % 与 MEM %: 容器使用的 CPU 和内存的百分比。
MEM USAGE / LIMIT: 容器正在使用的总内存，以及允许使用的内存总量。
NET I/O: 容器通过其网络接口发送和接收的数据量。
BLOCK I/O: 容器从主机上的块设备读取和写入的数据量。
PIDs: 容器创建的进程或线程数

13. docker container inspect

查看容器详细信息

docker container inspect [OPTIONS] CONTAINER [CONTAINER...]
• 关键参数
￮ -f :指定返回值的模板文件。如 table、json
￮ -s :显示总的文件大小。
• 注意事项：
￮ docker inspect 会自动检查是镜像还是容器然后显示相信信息

14. docker port

列出 指定 容器的 端口映射 ,或者查找将 PRIVATE_PORT NAT 到面向公众的端口

 // 什么参数不加 ,就是列车所有端口映射
查看 myweb8 容器的 80端口 映射的是宿主机的 什么端口
    docker port myweb8 80

15. docker cp

在容器 和 宿主机之间 拷贝 文件

语法
docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-   // 从容器 拷贝文件到 宿主机
docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH   // 从宿主机拷贝文件到 容器
                     //  container 就是容器的 id或name

16. docker diff

检查 容器文件结构的更改 (容器里改了什么地方,相比镜像)

docker diff CONTAINER

17. docker commit

从 容器 创建一个 新的镜像 (当容器里完成了各种业务 , 就可以创建成镜像 , 这个自定义镜像里就有我们容器的各种业务, 这样后面就可以直接用这个镜像 ,来完成 各种操作)

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]
• 参数
￮ -a :提交的镜像作者；
￮ -c :使用 Dockerfile 指令来创建镜像；可以修改启动指令  
    (// 例如: nginx镜像 , 他的默认启动命令式 nginx 参数-g xx , 
     // 后面, 我们从 容器创建的自定义镜像 , 就可以 通过-c ,来指定 启动镜像的 命令
    // 例如: 我们通过 nginx:1.2.0镜像创建容器 , 如果通过这个容器创建一个新的镜像 , 创建新的镜像后可以指定 启动命令
    // 启动命令: tail 参数 -h ,  这样 创建的这个镜像 , 这个自定义镜像 ,后面创建的容器 ,启动命令就是 tail -h
    )
    
￮ -m :提交时的说明文字；       // 相当于注释
￮ -p :在 commit 时，将容器暂停。

18. docker pause

暂停 容器中的 所有 进程

docker pause CONTAINER [CONTAINER...]

19. docker unpause

恢复容器中所有进程 , 刚好和 docker pause 相反 ,

20. docker rm

删除停止的 容器 ,

docker rm [OPTIONS] CONTAINER [CONTAINER...]
参数
-f :通过 SIGKILL 信号强制删除一个运行中的容器

21. docker export

把容器内容 导出成 tar文件 ,(把容器转成 tar文件 , 然后 可以 通过 docker import 把tar文件 转成 镜像)

docker export [OPTIONS] CONTAINER
参数
-o:写入到文件

22. docker wait

让容器阻塞运行, 直到容器停止 , 返回他的退出代码

23. docker rename

重命名容器

24. docker container prune

删除所有 停止的容器(非常危险)

25. docker update

更新容器配置

docker update [OPTIONS] CONTAINER [CONTAINER...]
    //参数
--cpus：cpu 数量
￮ --cpuset-cpus :使用哪些 cpu
￮ --memory :内存限制
￮ --memory-swap：交换内存
￮ --cpu-period :是用来指定容器对 CPU 的使用要在多长时间内做一次重新分配
￮ --cpu-quota：是用来指定在这个周期内，最多可以有多少时间用来跑这个容器

docker 容器操作

容器交互模式

1. attached模式: 容器在前台运行, (当退出 前台时 , 容器也停止了)

2. detached模式 : 容器在后台运行

3. interactive 模式 : 交互式运行 , (docker run -it)

MySQL容器安装

**1.**mysql容器的启动

docker run --name mysql -e MYSQL_ROOT_PASSWORD=123456 -p  8066:3306 -d mysql:5.7
   // 创建MySQL容器 ,指定容器名字: mysql , -e指定环境变量: 就是 mysql的root用户的密码是123456 , 
    // -p 给容器绑定端口映射 8066 : 3306, 方便我们从外面 操作 mysql 
    // -d 后台运行 , mysql版本5.7

**2.**在mysql 容器里,用 root和密码登录 ,创建数据库和数据表 ;

**3.**通过 数据库工具, 服务器地址 , 和 mysql容器 映射的端口号 , 和 mysql用户 和 密码 , 就可以远程连接上mysql容器里的mysql数据库

Redis 容器安装

Redis 简介

NoSQL 是非关系数据 , 而Redis就是 最热门的NoSQL 数据库 , 为了解决海量并发的数据问题 ,

Redis : Remoto Dictionary Server 远程字典服务器 , 是NoSQL非关系型数据库 ; 包含多种数据结构, 支持网络 , 基于内存 , 可持久性的 键值对存储 数据库 , Redis端口:6379

特点:

1. 基于内存运行 , 性能高效 (在内存里存取,速度非常快)

2. 支持分布式

3. key_value 键值对存储 (像Map一样)

4. 支持网络

Redis容器安装

1. redis 容器 创建

 docker run -d --name redis -p 8079:6379 redis:7
// 创建 redis容器 ,
     // -d后台运行 , name为 redis 
     // -p , 指定 端口映射 , 8079: 6379 , 
     // redis 版本 7

2. 进入到redis容器 , 通过redis进行操作

root@VM-12-9-ubuntu:~# docker exec -it redis bash    // 通过 exec 进入到容器里
root@68cd23a128a6:/data# redis-cli         // redis-cli (相当于redis-client客户端)进行到redis
127.0.0.1:6379> set testcount 1     //  set 存储键值对 key: testcout  value: 1 
OK                             
127.0.0.1:6379> get testcount      // 通过 get 获取 key的value
"1"
127.0.0.1:6379> set t2 2
OK
127.0.0.1:6379> get t2
"2"

3. 通过 数据库工具 远程连接 服务器上的redis容器 , 看到上面存储 的数据

C++容器制作

1. 创建ubuntu容器

 docker run -it  --name mygcc ubuntu:22.04 bash   // 加上bash

2. 进入容器 , 更换 apt国内镜像源

sed -i 's@//.*archive.ubuntu.com@//mirrors.ustc.edu.cn@g' /etc/apt/sources.list
 更换镜像源

3. 安装 gcc vim

apt install gcc vim -y

4. 编写c++代码

root@2a02c72e7d59:~# mkdir t1
root@2a02c72e7d59:~# cd t1
root@2a02c72e7d59:~/t1# vi test.c
root@2a02c72e7d59:~/t1# 
// 创建t1 目录, 创建 test.c 文件 , 在 test.c文件里编写hello docker的源代码

1. 编译代码 , 在容器中运行

root@2a02c72e7d59:~/t1# gcc test.c -o t2    // 使用gcc编译test.c源文件 , 然后可执行       文件名 为 t2
​
-rwxr-xr-x 1 root root 15960 Apr 10 13:37 t2*    //  编译完成的 t2 可执行文件
​
root@2a02c72e7d59:~/t1#  ./t2    // 通过 ./t2 来运行 t2
hello docker!       // 打印代码里的内容

SpringBoot 容器制作

编写SpringBoot demo

1. 在本地创建SpringBoot项目(jdk1.8 ; )

 <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.17</version>    // Spring2.7版本
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>  // 引入 Springweb依赖
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <build>             // build 引入打包容器 插件 , 让他在Maven打包后重新打包
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>    
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

2. 编写启动类和接口

3. 使用 Maven: clean 和 package 打包

(在 本地 通过 java -jar , 运行一下打包的jar包测试一下看打包的jar包是否可用)

制作容器

1. 创建 ubuntu容器 绑定好端口映射 ;

 docker run -it --name myjava -p 9088:8080 ubuntu:22.04 bash
   // 创建 ubuntu容器 ,                                  -it 交互 bash ,通过bash交互
     // 指定name : myjava
     // 指定端口映射 : 9088:8080                                  

2. 更换镜像源 , 下载jdk

root@c1ecfa17ad97:/#  sed -i 's@//.*archive.ubuntu.com@//mirrors.ustc.edu.cn@g' /etc/apt/sources.list
root@c1ecfa17ad97:/# apt update     
    // 更换镜像源 , 更新apt
     
     apt search jdk | grep 8   // 找一下 jdk 8 的包
    apt install openjdk-8-jdk  // 安装 jdk 8 
    
   

3. 把 本地的jar包 拷贝到 服务器 , 然后从 服务器 把jar包拷贝到容器里

 docker cp ./SpringContainer-1.0-SNAPSHOT.jar  myjava:/myjava/app.jar
       // 把jar包 复制到 myjava容器 的 /myjava目录底下 , 并命名为 app.jar
     现在容器就有 app.jar包

4. 运行jar包 , (java -jar app.jar 启动jar包)

在浏览器里,查看 服务器地址:映射的端口号 (服务器地址 : 9088 绑定的端口映射 , Spring里的/test/t1地址)

容器的生命周期

初建状态 : 容器刚被创建出来，但还没有启动过。

运行状态 : 容器正在正常运行，里面的应用在工作。

停止状态 : 容器被正常关闭，进程终止，但容器文件还在。

暂停状态 : 容器暂时冻结，所有进程暂停运行。

删除状态 : 容器被彻底删除，文件、配置、数据全部清除。

离线迁移镜像

在离线状态下迁移镜像

1. 先把镜像通过 docker save 导出成 tar文件 , 
2. 通过 scp xxx.tar root@43.01.xx.xx : /data/yy  
3. 输入 对方的密码
       // 通过 scp命令 , 把 xxx.tar文件 传给43.01.xx.xx服务器的root用户 , 存储在对端机器的 /data/yy 目录下
    // 后面 43.01.xx.xx 机器上就收到了 这个文件, 就可以直接使用这个镜像
​