曹大大
曹大大

记录一次Docker的学习

Docker学习

  • Docker概述
  • Docker安装
  • Docker命令
    • 镜像命令
    • 容器命令
    • 操作命令
    • ...
  • Docker实战操作（Nginx,Tomcat,ES,fastDFS...）
  • Docker镜像！
  • 容器数据卷！
  • DockerFile(构建镜像)
  • Docker网络原理
  • IDEA整合Docker
  • Docker Compose(集群)

Docker概述

Docker为什么会出现？

一款产品：开发---上线 两套环境！应用环境，应用配置！

开发---运维，问题：我在我电脑上可以运行！版本更新，导致服务不可用！

开发即运维！

环境配置是十分的麻烦，每个机器都要部署环境（Redis、ES、Hadoop...）费时费力。

发布一个项目（jar+（Redis、MySQL、JDK、ES）环境），即项目配上环境安装打包！

Windows最后发布到Linux上，环境天差地别，配置超麻烦，不能够跨平台！

传统流程：开发jar，运维来做！

现在流程：开发打包部署，一套流程！

Docker给以上的问题，提出了解决方案！

Docker的思想就来自于集装箱！

JRE ----多个应用（端口冲突） ---原来都是交叉的！

隔离：Docker核心思想！打包装箱！每个箱子是项目隔离的。

Docker通过隔离机制，可以将服务器运用到极致！

本质：所有的技术都是因为出现了一些问题，我们需要去解决，才去学习！

Docker的历史

2010年，几个搞IT的年轻人，就在美国成立了一家公司dotCloud做一些paas云计算服务！LXC有关的容器技术！

他们将自己的技术（容器技术）命名为Docker。

Docker刚开始没有引起行业的注意！然后活不下去，就去做开源。

2013年把Docker开源了。

Docker越来越多的人发现了docker的优点！火了，Docker每个月都会更新一个版本！

2014年4月9日，Docker1.0发布！

Docker为什么那么火？十分的轻巧！

在容器技术之前，我们使用的是虚拟机技术！

虚拟机：在Windows中装一个VM，通过这个软件我们可以虚拟出来一台或者多台电脑。笨重！

虚拟机也是属于虚拟化技术，Docker容器技术也是一种虚拟化技术！

vm,linux centos原生镜像（一个电脑！）隔离，需要开启多个虚拟机！
docker，隔离 镜像（最核心的环境4m+jdk+mysql）十分的小巧，运行镜像即可！秒级启动！

官网：https://www.docker.com/

文档：https://docs.docker.com/ （Docker的文档是超级详细的）

仓库地址：https://hub.docker.com/

Docker能干什么？

传统方式（虚拟机技术）

image-20220613123246575.png

虚拟机技术缺点：

  • 资源占用十分多
  • 冗余步骤多
  • 启动很慢

容器化技术

容器化技术不是模拟的一个完整的操作系统。

image-20220613124613646.png

比较Docker和虚拟机技术的不同：

  • 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件。
  • 容器内的应用直接运行在宿主机的内容，容器时没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
  • 每个容器间是相互隔离的，每个容器内都有一个自己的文件系统，互不影响。

DevOps(开发、运维)

应用更快的交付和部署。

传统：一堆帮助文档，安装程序。

Docker:打包镜像发布测试，一键运行。

更快的升级和扩容。

使用了Docker之后，我们部署应用就和搭积木一样！

项目打包为一个镜像，扩展 服务器A！服务器B。

更简单的系统运维。

在容器化之后，我们的开发，测试环境都是高度一致的。

Docker是内核级别的虚拟化，可以再一个物理机上运行很多的容器实例。

Docker安装

Docker的基本组成

image-20220613131540902.png

镜像（Image）:

Docker镜像就好比是一个模板，可以通过这个模板来创建容器服务，tomcat镜像===>run==>tomcat01容器，通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中）

容器（container）:

Docker利用容器技术，独立运行一个或者一个组应用，通过镜像来创建的。

启动，停止，删除，基本命令！

目前就可以把这个容器理解为就是一个简易的linux系统。

仓库（repository）：

仓库是存放镜像的地方！

仓库分为公用仓库和私有仓库。

阿里云,,,都有容器服务（配置镜像加速！），Docker Hub(默认是国外的)

安装Docker

环境准备

  1. CentOS7
  2. 使用Xshell或者MobaXterm远程连接服务器进行操作！

环境查看

# 系统内核是3.10以上的
[root@contos7 /]# uname -r
3.10.0-957.el7.x86_64

# 系统版本
[root@contos7 /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"

安装

image-20220613132715433.png
image-20220613132915739.png

OS requirements

To install Docker Engine, you need a maintained version of CentOS 7, CentOS 8 (stream), or CentOS 9 (stream). Archived versions aren’t supported or tested.

操作系统需求

安装Docker Engine需要CentOS 7、CentOS 8(流)或CentOS 9(流)的维护版本。 存档版本不受支持或测试。

#1.卸载旧的Docker
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

安装方法：

  • 大多数用户 设置 Docker 的存储库并从中安装，以便于安装和升级任务。这是推荐的方法。
  • 一些用户下载 RPM 包并 手动安装它并完全手动管理升级。这在一些情况下很有用，比如在没有互联网接入的气隙系统上安装Docker。
  • 在测试和开发环境中，一些用户选择使用自动化 便利脚本来安装 Docker。

使用存储库安装：

#2.需要的安装包
yum install -y yum-utils
#3.设置镜像的仓库（yum源地址）
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo #默认国外的
    
yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #建议阿里云
    
    
#更新yum软件包索引
yum makecache fast

#4.安装Docker相关的额 docke-ce社区 ee企业版
yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

#5.启动docker
systemctl start docker

#6.查看docker的版本状况
[root@contos7 /]# docker version
Client: Docker Engine - Community
 Version:           20.10.17
 API version:       1.41
 Go version:        go1.17.11
 Git commit:        100c701
 Built:             Mon Jun  6 23:05:12 2022
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.17
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.17.11
  Git commit:       a89b842
  Built:            Mon Jun  6 23:03:33 2022
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.6.6
  GitCommit:        10c12954828e7c7c9b6e0ea9b0c02b01407d3ae1
 runc:
  Version:          1.1.2
  GitCommit:        v1.1.2-0-ga916309
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

#7.通过运行hello-world映像来验证Docker Engine是否正确安装
[root@contos7 /]# docker run hello-world
#没有找到hello-world这个镜像
.Unable to find image 'hello-world:latest' locally
#然后去pull去拉取这个镜像
latest: Pulling from library/hello-world
#拉取的签名信息
2db29710123e: Pull complete
Digest: sha256:80f31da1ac7b312ba29d65080fddf797dd76acfb870e677f390d5acba9741b17
Status: Downloaded newer image for hello-world:latest

#执行到这里说明docker启动成功了
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/


#8.查看下载的这个hello-world镜像
[root@contos7 /]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB

了解：卸载Docker。

#卸载 Docker Engine、CLI、Containerd 和 Docker Compose 软件包
yum remove docker-ce docker-ce-cli containerd.io docker-compose-plugin
#主机上的映像、容器、卷或自定义配置文件不会自动删除。要删除所有映像、容器和卷。您必须手动删除任何已编辑的配置文件。
rm -rf /var/lib/docker   #默认工作路径
rm -rf /var/lib/containerd

阿里云镜像加速

  1. 登录阿里云找到镜像服务
  2. 找到镜像加速位置
  3. 配置使用
#1.创建文件夹
sudo mkdir -p /etc/docker
#2.执行
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://xxxxxxxxx"]
}
EOF
#3.重启服务
sudo systemctl daemon-reload
#4.重启docker
sudo systemctl restart docker

执行HelloWorld的流程

[root@contos7 /]# docker run hello-world
#没有找到hello-world这个镜像
.Unable to find image 'hello-world:latest' locally
#然后去pull去拉取这个镜像
latest: Pulling from library/hello-world
#拉取的签名信息
2db29710123e: Pull complete
Digest: sha256:80f31da1ac7b312ba29d65080fddf797dd76acfb870e677f390d5acba9741b17
Status: Downloaded newer image for hello-world:latest

#执行到这里说明docker启动成功了
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Run命令流程图：

image-20220613151257700.png

底层原理

Docker是怎么工作的？

Docker是一个Client-Server结构的系统，Docker的守护进程运行在主机上，通过Socket从客户端访问。

DockerServer接收到Docker-Client的指令，就会执行这个命令！

Docker为什么比虚拟机快？

  1. Docker有着比虚拟机更少的抽象层。
  2. Docker利用的是宿主机的内核，vm需要的是Guest OS。
image-20220613153614373.png

所以说，新建一个容器的时候，docker不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载Guest OS(分钟级别)，docker是利用宿主机的操作系统，省略了这个复杂的过程（秒级）。

LXC是Linux Container和docker一样也是虚拟容器技术。虚拟化技术分全虚拟、半虚拟和容器技术三大类。

Docker的常用命令

帮助命令

docker version  #显示docker的基本信息
docker info     #显示docker的系统信息，包括镜像和容器的数量
docker --help   #万能命令

帮助文档：https://docs.docker.com/reference/

镜像命令

docker images #查看所有本地的主机上的镜像

[root@contos7 ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB

#解释
REPOSITORY  镜像的仓库源
TAG         镜像的标签
IMAGE ID    镜像的id
CREATED     镜像的创建时间
SIZE        镜像的大小

#可选项
 -a, --all             #列出所有的镜像
 -q, --quiet           #只显示镜像ID

docker search #搜索镜像

[root@contos7 ~]# docker search mysql
NAME            DESCRIPTION                             STARS     OFFICIAL   AUTOMATED
mysql           MySQL is a widely used, open-source     12717     [OK]

#可选项，通过收藏来过滤
--filter=STARS=3000 #搜索出来的镜像就是STARS大于3000的

docker pull #下载镜像

#下载mysql镜像 docker pull 镜像名[:tag]指定版本，默认是最新版的
[root@contos7 ~]# docker pull mysql
Using default tag: latest  #如果不写tag，默认是latest
latest: Pulling from library/mysql
72a69066d2fe: Pull complete #分层下载，docker image的核心 联合文件系统
93619dbc5b36: Pull complete
99da31dd6142: Pull complete
626033c43d70: Pull complete
37d5d7efb64e: Pull complete
ac563158d721: Pull complete
d2ba16033dad: Pull complete
688ba7d5c01a: Pull complete
00e060b6d11d: Pull complete
1c04857f594f: Pull complete
4d7cfa90e6ea: Pull complete
e0431212d27d: Pull complete
Digest: sha256:e9027fe4d91c0153429607251656806cc784e914937271037f7738bd5b8e7709 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest  #正式地址

#两者等价
docker pull mysql
docker pull docker.io/library/mysql:latest

#指定版本下载
[root@contos7 ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
72a69066d2fe: Already exists    #联合文件系统，存在的不需要重复下载
93619dbc5b36: Already exists
99da31dd6142: Already exists
626033c43d70: Already exists
37d5d7efb64e: Already exists
ac563158d721: Already exists
d2ba16033dad: Already exists
0ceb82207cd7: Pull complete
37f2405cae96: Pull complete
e2482e017e53: Pull complete
70deed891d42: Pull complete
Digest: sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7

docker rmi #删除镜像

[root@contos7 ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
mysql         5.7       c20987f18b13   5 months ago   448MB
mysql         latest    3218b38490ce   5 months ago   516MB
hello-world   latest    feb5d9fea6a5   8 months ago   13.3kB
[root@contos7 ~]# docker rmi -f c20987f18b13
Untagged: mysql:5.7
Untagged: mysql@sha256:f2ad209efe9c67104167fc609cca6973c8422939491c9345270175a300419f94
Deleted: sha256:c20987f18b130f9d144c9828df630417e2a9523148930dc3963e9d0dab302a76
Deleted: sha256:6567396b065ee734fb2dbb80c8923324a778426dfd01969f091f1ab2d52c7989
Deleted: sha256:0910f12649d514b471f1583a16f672ab67e3d29d9833a15dc2df50dd5536e40f
Deleted: sha256:6682af2fb40555c448b84711c7302d0f86fc716bbe9c7dc7dbd739ef9d757150
Deleted: sha256:5c062c3ac20f576d24454e74781511a5f96739f289edaadf2de934d06e910b92

#删除多个容器
docker rmi -f 镜像id 镜像id 镜像id
#根据ID递归删除
docker rmi -f $(docker images -aq)

容器命令

说明：我们有了镜像才可以创建容器，linux，下载一个centos镜像来测试。

docker pull centos

新建容器并启动

docker run [可选参数] image

#参数说明
--name="Name"   #容器名字 tomcat01 tomcat02 用来区分容器
-d              #后台运行容器打印容器id
-it             #使用交互方式运行，进入容器查看内容
-p              #指定容器的端口 -p 8080
    -p ip:主机端口：容器端口
    -p 主机端口：容器端口（常用）
    -p 容器端口
    容器端口
-P              #随机指定端口

#测试，启动并进入容器
[root@contos7 ~]# docker run -it centos /bin/bash
[root@351facd9ba6d /]#

列出所有的运行的容器

[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@contos7 ~]# docker ps -a
CONTAINER ID   IMAGE          COMMAND       CREATED          STATUS                      PORTS     NAMES
351facd9ba6d   centos         "/bin/bash"   16 minutes ago   Exited (0) 11 minutes ago             nice_franklin
89cbf09d418c   feb5d9fea6a5   "/hello"      24 hours ago     Exited (0) 24 hours ago               pensive_noether
53c1882c2fb8   feb5d9fea6a5   "/hello"      24 hours ago     Exited (0) 24 hours ago               keen_payne
[root@contos7 ~]#

#参数说明（前面为空代表不带参数）
        #列出当前正在运行的容器
-a      #列出当前正在运行的容器+历史运行过得容器
-n=1    #显示n个最后创建的容器,默认-1
-q      #仅显示容器id

退出容器

#从容器中退到主机
ctrl+d
[root@351facd9ba6d /]# exit
exit
[root@contos7 ~]#

#容器不停止退出
Ctrl + P + Q

删除容器

docker rm 容器id      #删除指定的容器,不能删除正在运行的容器
docker rm -f 容器id   #强制删除指定的容器
docker rm -i         #删除指定链接
docker rm $(docker ps --filter status=exited -q)#移除所有停止的容器
docker rm $(docker ps -aq)  #递归删除所有的容器

启动和停止容器的操作

#因为同一个容器时可以run多次的
docker start 容器id
docker restart 容器id
docker stats 容器id
docker stop 容器id
docker kill 容器id

镜像是类，容器是一个实例，可以创建多个实例！启动的镜像就叫容器。

其他常用命令

后台启动命令

#通过run -d的命令后台启动
[root@contos7 ~]# docker run -d centos
27c2104d19fc674da2be8364973646849088caa4086e16792d40ac39db66d759
[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

问题：docker ps 查询不到这个容器，centos停止了

原因：docker容器使用后台运行的时候，就必须要有个前台进程，docker发现没有应用，就会自动停止。

例子：nginx容器启动后，发现自己没有提供服务，就会立刻停止，没有程序了。

查看日志命令

docker logs -f -t --tail 10 容器id

# 显示日志
-tf                 # 显示日志
--tail number       # 显示日志条数

#自己编写一段shell脚本,意思是创建一个容器执行一个while循环，每隔1秒输出一次"czy"
[root@contos7 ~]# docker run -d centos /bin/sh -c "while true;do echo czy;sleep 1;done"
98c3015c073a009e0e88bb07de2ffc9c94f1e7ea162f47f137d3afd47284df9a

查看容器的进程信息

docker top 容器id

查看镜像元数据

#docker inspect 容器id
[root@contos7 ~]# docker inspect 22d6148f3a0e
[
    {
        "Id": "22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa",
        "Created": "2022-06-15T06:02:46.50057874Z",
        "Path": "/bin/bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 3766,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2022-06-15T06:39:03.777802728Z",
            "FinishedAt": "2022-06-15T06:24:06.957362345Z"
        },
        "Image": "sha256:5d0da3dc976460b72c77d94c8a1ad043720b0416bfc16c52c45d4847e53fadb6",
        "ResolvConfPath": "/var/lib/docker/containers/22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa/hostname",
        "HostsPath": "/var/lib/docker/containers/22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa/hosts",
        "LogPath": "/var/lib/docker/containers/22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa/22d6148f3a0e4088af5d3b3790442d15af921cdd23b3d435973b2b691ca300fa-json.log",
        "Name": "/stoic_napier",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "CgroupnsMode": "host",
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": [],
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": [],
            "DeviceCgroupRules": null,
            "DeviceRequests": null,
            "KernelMemory": 0,
            "KernelMemoryTCP": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/e5dcb39b878197f005586e543bfe6829f372313a04ac1c190cc0fc1802770acb-init/diff:/var/lib/docker/overlay2/dab20efff82c1ae3f53af024241bb358f46c13a3909673d9a9347095050b5f28/diff",
                "MergedDir": "/var/lib/docker/overlay2/e5dcb39b878197f005586e543bfe6829f372313a04ac1c190cc0fc1802770acb/merged",
                "UpperDir": "/var/lib/docker/overlay2/e5dcb39b878197f005586e543bfe6829f372313a04ac1c190cc0fc1802770acb/diff",
                "WorkDir": "/var/lib/docker/overlay2/e5dcb39b878197f005586e543bfe6829f372313a04ac1c190cc0fc1802770acb/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "22d6148f3a0e",
            "Domainname": "",
            "User": "",
            "AttachStdin": true,
            "AttachStdout": true,
            "AttachStderr": true,
            "Tty": true,
            "OpenStdin": true,
            "StdinOnce": true,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "/bin/bash"
            ],
            "Image": "centos",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {
                "org.label-schema.build-date": "20210915",
                "org.label-schema.license": "GPLv2",
                "org.label-schema.name": "CentOS Base Image",
                "org.label-schema.schema-version": "1.0",
                "org.label-schema.vendor": "CentOS"
            }
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "83abe483c8b04091166f9dd56a116219a0f342405fee52958871cf08acb16aab",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/83abe483c8b0",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "504882501f375feded23a90a2a45334327f33ddba23996c70529e258f4b0bfc3",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "faa44104a20e02d30cb8ac930a212b8e4c70acd22fa308958a7498eb9a1baeb0",
                    "EndpointID": "504882501f375feded23a90a2a45334327f33ddba23996c70529e258f4b0bfc3",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

进入当前正在运行的容器

#我们通常容器都是使用后台方式运行，需要进入容器，修改一些配置

#方式-
#退出后（在运行状态下），重新进入容器
docker exec -it  容器id /bin/bash

#方式二
docker attach 容器id
[root@contos7 ~]# docker attach 22d6148f3a0e
[root@22d6148f3a0e /]#
正在执行的代码...

#docker exec    #进入容器后开启一个新的终端，可以在里面操作（常用）
#docker attach  #进入容器正在执行的终端，不会启动新的进程！

从容器内拷贝文件到主机上

docker cp 容器id:容器内路径 目的的主机路径

#演示
[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED       STATUS          PORTS     NAMES
22d6148f3a0e   centos    "/bin/bash"   3 hours ago   Up 40 minutes             stoic_napier
[root@contos7 ~]# docker attach 22d6148f3a0e
[root@22d6148f3a0e /]# ls
bin  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@22d6148f3a0e /]# cd home
[root@22d6148f3a0e home]# ls
[root@22d6148f3a0e home]# touch czy.java
[root@22d6148f3a0e home]# ls
czy.java
[root@22d6148f3a0e home]# exit
[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
[root@contos7 ~]# docker cp 22d6148f3a0e:/home/czy.java /home
[root@contos7 ~]# cd home
-bash: cd: home: No such file or directory
[root@contos7 ~]# ls
anaconda-ks.cfg
[root@contos7 ~]# cd ..
[root@contos7 /]# ls
bin  boot  dev  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
[root@contos7 /]# cd home
[root@contos7 home]# ls
czy.java
[root@contos7 home]#

小结

命令关系图.png

实战练习

Docker部署nginx

Docker部署nginx

  1. 搜素镜像，查看版本 search
  2. 下载镜像 pull
  3. 启动nginx
  4. 运行测试（出现welcome to nginx代表成功）
[root@contos7 ~]# docker search nginx
...各个版本信息
[root@contos7 ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
186b1aaa4aa6: Pull complete
b4df32aa5a72: Pull complete
a0bcbecc962e: Pull complete
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
[root@contos7 ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
mysql        latest    65b636d5542b   2 weeks ago    524MB
nginx        latest    605c77e624dd   5 months ago   141MB
centos       latest    5d0da3dc9764   9 months ago   231MB


#启动镜像生成容器 后台运行 起名nginx01 nginx的默认端口80映射到本机的3344端口
[root@contos7 xinetd.d]# docker run -d --name nginx01 -p 3344:80 nginx
bff2b9414455deac6b7326b08e86a507cfcd6dfb869038ea5828d9140a4522e8
[root@contos7 xinetd.d]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                                   NAMES
bff2b9414455   nginx     "/docker-entrypoint.…"   7 seconds ago   Up 7 seconds   0.0.0.0:3344->80/tcp, :::3344->80/tcp   nginx01

#测试启动
[root@contos7 xinetd.d]# curl localhost:3344



Welcome to nginx!




Welcome to nginx!


If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.



For online documentation and support please refer to
nginx.org.

Commercial support is available at
nginx.com.



Thank you for using nginx.




#进入nginx容器
[root@contos7 xinetd.d]# docker exec -it nginx01 /bin/bash
root@bff2b9414455:/# ls
bin  boot  dev  docker-entrypoint.d  docker-entrypoint.sh  etc  home  lib  lib64  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var
#寻找配置文件
root@bff2b9414455:/# whereis nginx.cof
nginx: /usr/sbin/nginx /usr/lib/nginx /etc/nginx /usr/share/nginx
root@bff2b9414455:/# cd /etc/nginx
root@bff2b9414455:/etc/nginx# ls
conf.d  fastcgi_params  mime.types  modules  nginx.conf  scgi_params  uwsgi_params
端口暴露的概念
image-20220617133203178.png

问题：我们每次改动nginx配置文件，都需要进入容器内部？十分麻烦，我要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改？

-v 数据卷

Docker部署Tomcat

官方的使用

docker run -it -rm tomcat:9.0

我们之前的启动都是后台，停止了容器之后，容器还是可以查到，-rm的操作的意思是用完即删，一般用来测试

#下载启动
docker pull tomcat:9.0
#启动运行
docker run -d --name tomcat01 -p 3345:8080 tomcat:9.0

#外网访问没有问题,但是出现了404
#进入容器
[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE        COMMAND                  CREATED             STATUS          PORTS                                       NAMES
ddfe33d15a30   tomcat:9.0   "catalina.sh run"        6 seconds ago       Up 5 seconds    0.0.0.0:3345->8080/tcp, :::3345->8080/tcp   tomcat01
bff2b9414455   nginx        "/docker-entrypoint.…"   About an hour ago   Up 39 minutes   0.0.0.0:3344->80/tcp, :::3344->80/tcp       nginx01
[root@contos7 ~]# docker exec -it ddfe33d15a30 /bin/bash

发现问题：1.linux命令少了 2.webapps目录下为空
原因：阿里云镜像的原因，默认是最小的镜像，所有的不必要的都剔除了，保证了最小可运行的环境
解决：可以把当前目录下的webapps.dist拷贝到webapps就可以显示Tomcat自己的页面了
cp -r webapps.dist/* webapps

思考：我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？我要是可以在容器外部提供一个映射路径，webapps，我们在外部放置项目，就自动同步到内部好了。

部署ES

es是一个日志切割管理工具！

es要暴露的端口很多！

es十分的消耗内存！

es的数据一般需要放置到安全目录！挂载

安装

#--net somenetwork ? 网络配置
#下载启动es
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

#如果是学习机器，内存cpu不足的情况下，会卡死，差不多1.x个G

#测试是否连通
[root@contos7 ~]# curl localhost:9200
{
  "name" : "3591db3dde12",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "FzmI_BYcRby4UpCzU4D5OA",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}


#增减内存限制，修改es配置文件，-e 环境配置修改(-e ES_JAVA_OPTS="-Xms64m -Xmx512m")
docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

可视化portainer

  • portainer
  • Rancher(CI/CD再用)

什么是portainer?

Docker图形化界面管理工具。提供一个后台面板供我们操作。

#安装
docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

地址：虚拟机ip:8088

登录页面：

image-20220620150622896.png

注意：创建用户密码不要太简单，不然不让创建。

然后选择local选项，选择本地，然后会提示你是否执行-v /var/run/docker.sock:/var/run/docker.sock指令，如果执行（上面命令已经执行）过则直接进入

页面：

image-20220620151539303.png

Docker安装FastDFS

介绍:FastDFS是一个开源的轻量级的分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传和文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站，视频网站等。

FastDFS服务端游连个角色：跟踪器（tracker）和存储节点（storage）。跟踪器主要是做调度工作，在访问上起负载均衡的作用。

[root@contos7 ~]# docker pull delron/fastdfs
[root@contos7 ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
delron/fastdfs           latest    8487e86fc6ee   4 years ago     464MB

#1.使用docker镜像构建tracker容器（跟踪服务器，起到调度作用）
docker run -dti --network=host --name tracker -v /var/fdfs/tracker:/var/fdfs -v /etc/localtime:/etc/localtime delron/fastdfs  tracker

#2.使用docker镜像构建storage容器（存储服务器，提供容量和备份服务,TRACKER_SERVER地址就是你上面运行的tracker容器地址）
docker run -dti --network=host --name storage -e TRACKER_SERVER=10.0.0.120:22122 -v /var/fdfs/storage:/var/fdfs -v /etc/localtime:/etc/localtime delron/fastdfs storage

#3.进入storage容器，到storage的配置文件http访问的端口，默认是8888，配置文件在/etc/fdfs目录下的storage.conf(不修改端口直接跳过)
#进入容器
docker exec -it storage bash

#进入目录
cd /etc/fdfs

#编辑文件
vi storage.conf

#4.修改storage中的nginx（如果第三步不修改端口的话这部也跳过）
cd /usr/local/nginx/conf
vi nginx.conf

#修改完后重启storage
docker stop storage
docker start storage

运行 docker container start storage 无法启动，进行如下操作即可：
可以删除/var/fdfs/storage/data目录下的fdfs_storaged.pid 文件，然后重新运行storage。

#5.开放端口
firewall-cmd --zone=public --permanent --add-port=8888/tcp
firewall-cmd --zone=public --permanent --add-port=22122/tcp
firewall-cmd --zone=public --permanent --add-port=23000/tcp

#重启防火墙
systemctl restart firewalld

#6.设置开机启动
docker update --restart=always tracker
docker update --restart=always storage

Docker镜像原理

镜像是什么？

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

所有应用，直接打包部署。

如何得到镜像？

  • 从远处仓库下载
  • 有人拷贝给你
  • 自己打包镜像

Docker镜像加载原理

UnionFS(联合文件系统)，pull文件的时候一层一层的就是这个

UnionFS联合文件系统是一种分层、轻量级并且高性能的文件系统，他支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同的目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行基础，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

Docker镜像加载原理

bootfs（boot file system）主要包含bootloader和kernel,bootloader主要是引导加载kernel,Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就是都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs(root file system),在bootfs之上。包含的就是典型Linux系统中的/dev,/proc,/bin/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu,Centos等等。

image.png

平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M？

image-20220621132225464.png

对于一个精简的OS，rootfs可以是很小，只需要包含基本的命令，工具和程序库就可以了，因为底层直接用Host的Kernel,自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发型版可以公用bootfs。

分层镜像

分层镜像

我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层一层的在下载。

image-20220621134611632.png

思考：为什么Docker镜像要采取这种分层的结构呢？

最大的好处，我觉得莫过于资源的共享！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需要在磁盘保留一份base镜像，同时内存中也只需要加载一份base镜像，这样的就可以为所有的容器服务，而镜像的每一层都可以被共享。

查看镜像分层的方式可以通过docker image inspect

"RootFS": {
            "Type": "layers",
            "Layers": [
                "sha256:2edcec3590a4ec7f40cf0743c15d78fb39d8326bc029073b41ef9727da6c851f",
                "sha256:9b24afeb7c2f21e50a686ead025823cd2c6e9730c013ca77ad5f115c079b57cb",
                "sha256:4b8e2801e0f956a4220c32e2c8b0a590e6f9bd2420ec65453685246b82766ea1",
                "sha256:529cdb636f61e95ab91a62a51526a84fd7314d6aab0d414040796150b4522372",
                "sha256:9975392591f2777d6bf4d9919ad1b2c9afa12f9a9b4d260f45025ec3cc9b18ed",
                "sha256:8e5669d8329116b8444b9bbb1663dda568ede12d3dbcce950199b582f6e94952"
            ]
        }

理解：

所有的Docker镜像都起始于一个基础镜像层，当进行修改或者增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举一个简单的例子，假如基于Ubuntu Linux 16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加Python包，就会在基础镜像之上创建第二个镜像层；如果继续添加一个安全补丁，就会创建第三层镜像。

image-20220621140627906.png

特点

Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部！

这一层就是我们通常说的容器层，容器之下的都叫镜像层！

commit镜像

docker commit 提交容器成为一个新的副本
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名:[TAG]

实战测试：

#启动一个默认的tomcat
docker run -it -p:8080:8080 tomcat /bin/bash
#发现这个默认的tomcat，是没有webapps应用的，是镜像原因，官方镜像默认没有
#我自己拷贝进去基本的文件
cp -r webapps.dist/* webapps

#把这个添加webapps的tomcat打包为tomcat02 1.0版本
[root@contos7 ~]# docker ps
CONTAINER ID   IMAGE                 COMMAND             CREATED        STATUS          PORTS                                       NAMES
1d40c549a78a   portainer/portainer   "/portainer"        25 hours ago   Up 2 hours      0.0.0.0:8088->9000/tcp, :::8088->9000/tcp   cool_lamport
ddfe33d15a30   tomcat:9.0            "catalina.sh run"   4 days ago     Up 22 minutes   0.0.0.0:3345->8080/tcp, :::3345->8080/tcp   tomcat01
[root@contos7 ~]# docker commit -a="czy" -m="add webapps" ddfe33d15a30 tomcat02:1.0
sha256:a3c1c255684027f755ad98a357ffbd095f6e7c89c867ec4ac8d40b5ecbab1952
[root@contos7 ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
tomcat02                 1.0       a3c1c2556840   5 seconds ago   685MB
mysql                    latest    65b636d5542b   3 weeks ago     524MB
nginx                    latest    605c77e624dd   5 months ago    141MB
tomcat                   9.0       b8e65a4d736d   6 months ago    680MB
redis                    latest    7614ae9453d1   6 months ago    113MB
portainer/portainer-ce   2.9.3     ad0ecf974589   7 months ago    252MB
centos                   latest    5d0da3dc9764   9 months ago    231MB
portainer/portainer      latest    580c0e4e98b0   15 months ago   79.1MB
elasticsearch            7.6.2     f29a1ee41030   2 years ago     791MB

注意此时镜像大小发生了一点改变。

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像。

到了这里才算是入门Docker！

容器数据卷

什么是容器数据卷？

docker的理念：

将应用和环境打包成一个镜像！

数据放在哪里？如果放在容器里，那么容器一删除，数据就会丢失! 需求：数据可以持久化。

MySQL，容器删了==删库跑路！MySQL的数据可以存储在本地或者其它地方

容器之间可以有一个数据共享的技术！Docker容器中产生的数据，同步到本地！数据就不会丢失（只是针对这个问题而言），这就是卷技术。目录的挂载，将我们的容器内的目录挂载到Linux上面。

image-20220621164936072.png

总结：为什么使用卷技术？因为容器的持久化和同步操作！容器间也是可以数据共享的。

使用数据卷

方式一：直接使用命令来挂载 -v

docker run -it -v 主机目录地址：容器目录地址

#启动centos 把容器的home目录挂载到主机的home/ceshi目录下
docker run -it -v /home/ceshi:/home centos /bin/bash

这样两个目录就可以同步文件了。

#启动之后，可以查看是否挂载成功
docker inspect 容器id
image-20220621171105021.png

这个文件目录的挂载类似于双向绑定的概念！

  • 在容器stop的时候，你去修改主机挂载目录里的文件，然后启动容器，你会发现容器挂载的目录里的文件同样被修改。
  • 如果在start状态下直接docker rm -f 容器，则不会变动主机挂载目录的文件。
  • 重新创建容器挂载到有文件的目录，则会从主机自动映射文件到容器。

好处：我们以后修改只需要在本地修改即可，容器会自动同步映射。

实战测试：安装MySQL

思考：MySQ的数据持久化问题

操作

docker search mysql
#获取镜像
docker pull mysql:5.8
#运行容器，需要做数据挂载，安装启动mysql，需要配置密码，这也是要注意的点
#官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.8

#启动成功之后，我们在本地使用mysql连接工具测试连接

#在本地测试创建一个数据库，查看一下我们映射的路径是否ok!

#容器直接删除，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能

具名挂载和匿名挂载

#匿名挂载
-v 容器内路径
[root@contos7 ~]# docker run -d -P --name nginx01 -v /etc/nginx nginx

#查看所有的卷的情况
[root@contos7 ~]# docker volume ls
local     5685b30f76d4411807e168d57662402b90e542a5f60a246fcf0ab02d17c367fd
#这里发现，这种就是匿名挂载，我们在-v只写了容器内的路径，没有写容器外的路径！

#去元数据中查看挂载目录
[root@contos7 ~]# docker inspect 4903118ae272(nginx-id)
image-20220710113505852.png 
#具名挂载
-v 卷名称：容器内路径
[root@contos7 ~]# docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

[root@contos7 ~]# docker volume ls
image-20220623133413327.png

所有的docker容器内的卷，没有指定目录的情况下都是在 /var/lib/docker/volumes/xxx/_data路径下。

我们通过具名挂载可以方便的找到我们的一个卷，大多数情况下在使用的。

如何确定是具名挂载还是匿名挂载，还是指定路径下载？

-v 容器内的路径 #匿名挂载

-v 卷名 : /容器内的路径 #具名挂载

-v /宿主机路径 : /容器内路径 #指定路径挂载

拓展：

#通过 -v 容器内路径： ro rw 改变读写权限
#ro readOnly
#rw readWrite

#一旦这个设置了容器权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

#ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作的。

初识DockerFile

DockerFile就是来构建docker镜像的构建文件！（命令脚本）

#在/home目录下创建一个docker-test-volume目录
mkdir docker-test-volume
#生成一个写脚本文件
vim dockerfile

编写dockerfile

#创建一个dockerfile文件名字可以随机 建议Dockerfile
#通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个一个的命令，每个命令都是一层
FROM centos

VOLUME ["volume01","volume02"]

CMD echo "----end----"

CMD /bin/bash

#这里的每一个命令，就是镜像的一层。

执行脚本

#docker bulid -f "dockerfile文件路径" -t "生成的镜像名称:tag" .

[root@contos7 docker-test-volume]# docker build -f dockerfile -t czy/centos:1.0 .                                                                        Sending build context to Docker daemon  14.85kB
Step 1/4 : FROM centos
 ---> 5d0da3dc9764
Step 2/4 : VOLUME ["volume01","volume02"]
 ---> Running in 5f198356ee9f
Removing intermediate container 5f198356ee9f
 ---> 13557b8f86de
Step 3/4 : CMD echo "----end----"
 ---> Running in 4055653538bc
Removing intermediate container 4055653538bc
 ---> 9adf3a8eafe1
Step 4/4 : CMD /bin/bash
 ---> Running in fa5f92dd6a82
Removing intermediate container fa5f92dd6a82
 ---> 0d08795356a2
Successfully built 0d08795356a2
Successfully tagged czy/centos:1.0
[root@contos7 docker-test-volume]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED              SIZE
czy/centos               1.0       0d08795356a2   About a minute ago   231MB

运行

[root@contos7 docker-test-volume]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
czy/centos               1.0       0d08795356a2   5 hours ago     231MB
tomcat02                 1.0       a3c1c2556840   3 days ago      685MB
mysql                    latest    65b636d5542b   3 weeks ago     524MB
nginx                    latest    605c77e624dd   5 months ago    141MB
tomcat                   9.0       b8e65a4d736d   6 months ago    680MB
redis                    latest    7614ae9453d1   6 months ago    113MB
portainer/portainer-ce   2.9.3     ad0ecf974589   7 months ago    252MB
centos                   latest    5d0da3dc9764   9 months ago    231MB
portainer/portainer      latest    580c0e4e98b0   15 months ago   79.1MB
elasticsearch            7.6.2     f29a1ee41030   2 years ago     791MB
[root@contos7 docker-test-volume]# docker run -it --name czy-centos 0d08795356a2 /bin/bash
[root@1ad1c81445f9 /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Jun 24 07:52 dev
drwxr-xr-x.   1 root root  66 Jun 24 07:52 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 128 root root   0 Jun 24 07:52 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Jun 24 02:24 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var

#出现了刚才挂载的两个目录，这个目录就是我们生成镜像的时候自动挂载的
drwxr-xr-x.   2 root root   6 Jun 24 07:52 volume01
drwxr-xr-x.   2 root root   6 Jun 24 07:52 volume02
[root@1ad1c81445f9 /]#

#在volume01中创建一个文件
touch czy.txt

使用docker inspect 查看挂载路径

image-20220627140407685.png

同步成功：

image-20220627140509594.png

测试刚才的目录挂载出去了！

这种方式我们未来使用的十分的多，因为我们通常会构建自己的镜像！

假设构建镜像时候没有挂载卷，要手动镜像挂载 -v 卷名：容器内路径！

数据卷容器

两个MySQL同步数据（两个容器之间的目录挂载，实际上数据只有一份）！

image-20220628155717267.png

启动3台服务

[root@contos7 ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
czy/centos               1.0       0d08795356a2   4 days ago      231MB

启动docker01

image-20220629151259549.png

启动docker02

image-20220629153011776.png

往docker01里添加文件

#进入docker01并在volume01下创建文件

[root@contos7 ~]# docker attach 81caecb32880
[root@81caecb32880 /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Jun 29 02:16 dev
drwxr-xr-x.   1 root root  66 Jun 29 02:16 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 130 root root   0 Jun 29 02:16 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Jun 29 01:04 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var
drwxr-xr-x.   2 root root   6 Jun 29 02:16 volume01
drwxr-xr-x.   2 root root   6 Jun 29 02:16 volume02
[root@81caecb32880 /]# cd volume01/
[root@81caecb32880 volume01]# touch docker01
[root@81caecb32880 volume01]#

则docker02也会出现docker01创建的文件

image-20220629153511109.png

启动docker03挂载docker01

[root@contos7 ~]# docker run -it --name docker03 --volumes-from docker01 czy/centos:1.0 /bin/bash
[root@f5bc776216ec /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3  2020 bin -> usr/bin
drwxr-xr-x.   5 root root 360 Jun 29 07:39 dev
drwxr-xr-x.   1 root root  66 Jun 29 07:39 etc
drwxr-xr-x.   2 root root   6 Nov  3  2020 home
lrwxrwxrwx.   1 root root   7 Nov  3  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3  2020 lib64 -> usr/lib64
drwx------.   2 root root   6 Sep 15  2021 lost+found
drwxr-xr-x.   2 root root   6 Nov  3  2020 media
drwxr-xr-x.   2 root root   6 Nov  3  2020 mnt
drwxr-xr-x.   2 root root   6 Nov  3  2020 opt
dr-xr-xr-x. 133 root root   0 Jun 29 07:39 proc
dr-xr-x---.   2 root root 162 Sep 15  2021 root
drwxr-xr-x.  11 root root 163 Sep 15  2021 run
lrwxrwxrwx.   1 root root   8 Nov  3  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3  2020 srv
dr-xr-xr-x.  13 root root   0 Jun 29 01:04 sys
drwxrwxrwt.   7 root root 171 Sep 15  2021 tmp
drwxr-xr-x.  12 root root 144 Sep 15  2021 usr
drwxr-xr-x.  20 root root 262 Sep 15  2021 var
drwxr-xr-x.   2 root root  22 Jun 29 07:33 volume01
drwxr-xr-x.   2 root root   6 Jun 29 02:16 volume02
[root@f5bc776216ec /]# cd volume01
[root@f5bc776216ec volume01]# ls
docker01
[root@f5bc776216ec volume01]#

所以使用 --volumes-from 容器，就可以使容器间的数据共享。

因为docker02和docker03都挂载于docker01,这个时候把docker01停掉并且把镜像删除，docker02和docker03中的数据会删除吗？

不会

在docker01删除后，在docker02中添加数据，在docker03的目录下能访问到吗？

可以，三者互通，在inspect查看下，发现三者都在使用宿主机下的同一个卷，映射。

多个mysql实现数据共享

docker run -d -p 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.8

docker run -d -p 3311:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.8

#这个时候，可以实现两个容器数据同步！

结论：容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止！

DockerFile

dockerfile是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

  1. 编写一个dockerfile文件
  2. docker build构件成一个镜像
  3. docker run 运行镜像
  4. docker push发布镜像（DockerHub、阿里云镜像）

查看一下官方是怎么做的

image-20220711170442029.png

点击版本跳转到github，其实也是dockerfile

image-20220711170632028.png

很多官方的镜像都是基础包，很多功能都没有，我们通常会自己去搭建自己的镜像！

官方既然可以制作镜像，那我们也可以！

DockerFile建过程

基础知识：

  1. 每一个保留的关键字（指令）都必须是大写字母
  2. 执行从上到下顺序执行
  3. "#"表示注释
  4. 每个指令都会创建提交一个新的镜像层，并提交！
image-20220711171722208.png

DockerFile是面向开发的，我们以后要发布项目，做镜像，就是要编写dockerfile文件，这个文件十分简单！

Docker镜像逐渐成为企业交付的标准，必须要掌握！

总结：

  1. DockerFile：构建文件，定义一切的步骤，相当于源代码。
  2. DockerImage:通过DockerFile构建生成的镜像，最终发布和运行的产品，原来是jar和war。
  3. DockerContainer:容器就是镜像运行起来提供服务的。

DockerFile指令

FROM        #基础镜像,一切从这里开始构建，假如是centos
MAINTAINER  #镜像是谁写的，姓名+邮箱
RUN         #镜像构建的时候需要运行的命令
ADD         #步骤，搭建tomcat镜像，这个tomcat压缩包！添加内容
WORKDIR     #镜像的工作目录
VOLUME      #挂载的目录位置
EXPOSE      #暴露端口配置
CMD         #指定这个容器启动的时候运行的命令，只有最后一个会生效，可以被替代
ENTRYPOINT  #指定这个容器启动的时候需要运行的命令，可以追加命令
ONBUILD     #是一个特殊的指令，它后面跟的是其它的指令，比如RUN,COPY等，而这些指令，在镜像构建的时候不会被执行，只有当以当前镜像为基础镜像去构建下一级镜像的时候才会被执行。当构建一个被继承DockerFile，这个时候就会运行ONBUILD的指令，是一个触发指令。
COPY        #类似于ADD，将我们的文件拷贝到镜像中
ENV         #构建的时候设置环境变量，例子：mysql -e MYSQL_ROOT_PASSWORD=123456
image-20220714170252621.png

构建一个自己的centos

注意：构建之前，需要先pull一下指定版本的centos，不然会自动下载一个最新的。

Docker中百分之99的镜像都是从scratch开始的，然后配置需要的软件和配置来进行构建。

image-20220718091819931.png 
#在home目录创建一个名字叫dockerfile的文件夹
mkdir dockerfile

cd dockerfile

vim mycentosdockerfile

#我们来升级一下官方的centos,因为是压缩的，所以一些基础的命令都没有，例如ifconfig,vim

#1.编写dockerfile文件内容
FROM centos：centos7

MAINTAINER czy<[email protected]

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "---end---"
CMD /bin/bash

#2.通过这个文件来构建我们的镜像
docker build -f mycentosdockerfile -t mycentos:0.1 .
#最后打印这个代表构建成功
Successfully built 2975be88c013
Successfully tagged mydockerfilecentos:0.1

#3.测试运行
docker run -it --name="dockerfilecentos" mydockerfile /bin/bash

[root@4fc19af8a1d6 local]# ifconfig
eth0: flags=4163  mtu 1500
        inet 172.17.0.3  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:03  txqueuelen 0  (Ethernet)
        RX packets 8  bytes 656 (656.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

对比官方镜像

官方镜像是没有vim,ifconfig这些命令的，且工作目录是/

自己刚才构建的：

image-20220718102203362.png 
#可以查看怎样一步一步的构建镜像的，--no-trunc=true可以使过程更加详细
docker history 镜像id --no-trunc=true

[root@contos7 dockerfile]# docker history 2975be88c013
IMAGE          CREATED          CREATED BY                                      SIZE      COMMENT
2975be88c013   26 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B
da79ec2fa0a2   26 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B
099ccf98549f   26 minutes ago   /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B
738ee3093466   26 minutes ago   /bin/sh -c #(nop)  EXPOSE 80                    0B
a0ee236010cc   26 minutes ago   /bin/sh -c yum -y install net-tools             177MB
3d7568143c74   26 minutes ago   /bin/sh -c yum -y install vim                   232MB
11c7d8377b08   27 minutes ago   /bin/sh -c #(nop) WORKDIR /usr/local            0B
8da249782276   27 minutes ago   /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B
f8071f3fc441   27 minutes ago   /bin/sh -c #(nop)  MAINTAINER czy<1606987945…   0B
eeb6ee3f44bd   10 months ago    /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B
      10 months ago    /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B
      10 months ago    /bin/sh -c #(nop) ADD file:b3ebbe8bd304723d4…   204MB

CMD和ENTRYPOINT区别

CMD         #指定这个容器启动的时候运行的命令，只有最后一个会生效，可以被替代
ENTRYPOINT  #指定这个容器启动的时候需要运行的命令，可以追加命令

测试CMD

#1.创建一个dockerfile
[root@contos7 dockerfile]# vim dockerfile-cmd-test
FROM centos:centos7

CMD ["ls","-a"]
#2.构建镜像
docker build -f dockerfile-cmd-test -t docker-cmd-test:0.1 .
#3.镜像构建容器
[root@contos7 dockerfile]# docker run afd3b61045b0
.
..
.dockerenv
anaconda-post.log
bin
dev
etc
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var

#想追加一个命令 -l ls -al
[root@contos7 dockerfile]# docker run afd3b61045b0 -l
docker: Error response from daemon: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: exec: "-l": executable file not found in $PATH: unknown.

#CMD的情况下 -l 替换了CMD["ls","-a"]命令，-l不是命令所以报错
#正确写法
[root@contos7 dockerfile]# docker run afd3b61045b0 ls -al
total 12
drwxr-xr-x.   1 root root     6 Jul 18 04:48 .
drwxr-xr-x.   1 root root     6 Jul 18 04:48 ..
-rwxr-xr-x.   1 root root     0 Jul 18 04:48 .dockerenv
-rw-r--r--.   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx.   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x.   5 root root   340 Jul 18 04:48 dev
drwxr-xr-x.   1 root root    66 Jul 18 04:48 etc
drwxr-xr-x.   2 root root     6 Apr 11  2018 home
lrwxrwxrwx.   1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x.   2 root root     6 Apr 11  2018 media
drwxr-xr-x.   2 root root     6 Apr 11  2018 mnt
drwxr-xr-x.   2 root root     6 Apr 11  2018 opt
dr-xr-xr-x. 140 root root     0 Jul 18 04:48 proc
dr-xr-x---.   2 root root   114 Nov 13  2020 root
drwxr-xr-x.  11 root root   148 Nov 13  2020 run
lrwxrwxrwx.   1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root     6 Apr 11  2018 srv
dr-xr-xr-x.  13 root root     0 Jul 18 01:10 sys
drwxrwxrwt.   7 root root   132 Nov 13  2020 tmp
drwxr-xr-x.  13 root root   155 Nov 13  2020 usr
drwxr-xr-x.  18 root root   238 Nov 13  2020 var

测试ENTRYPOINT,直接追加命令

#dockerfile内容
FROM centos:centos7

ENTRYPOINT ["ls","-a"]

#此处是直接追加命令
[root@contos7 dockerfile]# docker run f1e9b84e07f0 -l
total 12
drwxr-xr-x.   1 root root     6 Jul 18 05:34 .
drwxr-xr-x.   1 root root     6 Jul 18 05:34 ..
-rwxr-xr-x.   1 root root     0 Jul 18 05:34 .dockerenv
-rw-r--r--.   1 root root 12114 Nov 13  2020 anaconda-post.log
lrwxrwxrwx.   1 root root     7 Nov 13  2020 bin -> usr/bin
drwxr-xr-x.   5 root root   340 Jul 18 05:34 dev
drwxr-xr-x.   1 root root    66 Jul 18 05:34 etc
drwxr-xr-x.   2 root root     6 Apr 11  2018 home
lrwxrwxrwx.   1 root root     7 Nov 13  2020 lib -> usr/lib
lrwxrwxrwx.   1 root root     9 Nov 13  2020 lib64 -> usr/lib64
drwxr-xr-x.   2 root root     6 Apr 11  2018 media
drwxr-xr-x.   2 root root     6 Apr 11  2018 mnt
drwxr-xr-x.   2 root root     6 Apr 11  2018 opt
dr-xr-xr-x. 140 root root     0 Jul 18 05:34 proc
dr-xr-x---.   2 root root   114 Nov 13  2020 root
drwxr-xr-x.  11 root root   148 Nov 13  2020 run
lrwxrwxrwx.   1 root root     8 Nov 13  2020 sbin -> usr/sbin
drwxr-xr-x.   2 root root     6 Apr 11  2018 srv
dr-xr-xr-x.  13 root root     0 Jul 18 01:10 sys
drwxrwxrwt.   7 root root   132 Nov 13  2020 tmp
drwxr-xr-x.  13 root root   155 Nov 13  2020 usr
drwxr-xr-x.  18 root root   238 Nov 13  2020 var

DockerFile中很多的命令都是十分相似的，我们需要了解它们的区别，我们最好的学习就是对比他们然后测试效果！

构建一个自己的Tomcat

  1. 准备镜像文件，tomcat压缩包，jdk压缩包！
    1. tomcat压缩包：https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.64/bin/apache-tomcat-9.0.64.tar.gz
    2. jdk压缩包：https://pan.baidu.com/s/1RCEJfWgTkAE1pVm-DeLrzw 密码：iu94(别人的百度云盘)
  2. 编写dockerfile文件，官方命名 DockerFile ,build会自动寻找这个文件，就不需要-f指定了。
#1.在home目录下创建一个tomcat文件夹
mkdir tomccat
#2.上传两个文件一个是tomcat压缩包一个是jdk压缩包
[root@contos7 tomcat]# ll
total 201832
-rw-r--r--. 1 root root  11579290 Jul 18 16:24 apache-tomcat-9.0.64.tar.gz
-rw-r--r--. 1 root root 195094741 Jul 18 16:24 jdk-8u221-linux-x64.tar.gz
#3.创建备注文档，准备编写dockerfile文件
[root@contos7 tomcat]# touch readme.txt
[root@contos7 tomcat]# vim Dockerfile

FROM centos:centos7

MAINTAINER czy<[email protected]

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u221-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.64.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_221
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib.tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.64
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.64
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-9.0.64/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.64/logs/catalina.out

3.构建镜像

#通过docker build -t 镜像名称：版本号 . 直接构建

#构建成功后，启动把webapps目录和日志挂载到外部
[root@contos7 tomcat]# docker run -d -p 9090:8080 --name czy-div-tomcat -v /home/tomcat/test:/usr/local/apache-tomcat-9.0.64/webapps/test -v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.64/logs diytomcat:0.1
image-20220719141247816.png
image-20220719141341906.png

4.测试访问

虚拟机ip:9090

5.发布项目（因为使用了卷挂载，直接上传到本地就行）

#在webapps目录下创建WEB-INF目录，在目录里创建web.xml
cd webapps
cd test
mkdir WEB-INF
touch web.xml

web.xml内容






#与webapps同级创建index.jsp
vim index.jsp

#vim出现中文乱码的问题
#1.用vim打开 .vimrc配置文件
vim ~/.vimrc
#2.在配置文件中加入一下内容，然后退出保存
set termencoding=utf-8
set encoding=utf8
set fileencodings=utf8,ucs-bom,gbk,cp936,gb2312,gb18030

index.jsp内容：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>


life.jsp



<%!
  private int initVar=0;
  private int serviceVar=0;
  private int destroyVar=0;
%>

<%!
  public void jspInit(){
    initVar++;
    System.out.println("jspInit(): JSP被初始化了"+initVar+"次");
  }
  public void jspDestroy(){
    destroyVar++;
    System.out.println("jspDestroy(): JSP被销毁了"+destroyVar+"次");
  }
%>

<%
  serviceVar++;
  System.out.println("_jspService(): JSP共响应了"+serviceVar+"次请求");

  String content1="初始化次数 : "+initVar;
  String content2="响应客户请求次数 : "+serviceVar;
  String content3="销毁次数 : "+destroyVar;
%>


菜鸟教程 JSP 测试实例


<%=content1 %>


<%=content2 %>


<%=content3 %>

测试：

虚拟机ip:9090/test/index.jsp
image-20220719152453823.png 
#出现上述页面，则测试成功！

我们以后开发的步骤：需要掌握DockerFile的编写！我们之后的一切都是使用docker镜像来发布运行！

发布镜像到DockerHuB

发布到DockerHub

  1. 地址：https://hub.docker.com/ 注册自己的账号
  2. 确定这个账号可以登录
  3. 在我们服务器上提交自己的镜像
[root@contos7 tomcat]# docker login --help

Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username
  
#密码错误
[root@contos7 tomcat]# docker login -u 账号
Password: 密码
Error response from daemon: Get "https://registry-1.docker.io/v2/": unauthorized: incorrect username or password

#密码正确
[root@contos7 tomcat]# docker login -u 账号
Password: 密码
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
[root@contos7 tomcat]#

4.登录完毕后就可以push镜像了。

#docker push 镜像名称：版本号

[root@contos7 tomcat]# docker push diytomcat:0.1
The push refers to repository [docker.io/library/diytomcat]
b66cfcd4e406: Retrying in 1 second
d2b5579aad7b: Retrying in 1 second
eb14e90b8576: Retrying in 1 second
8fde005537ac: Retrying in 1 second
174f56854903: Retrying in 1 second
denied: requested access to the resource is denied

#已经登录，但是出现了错误，应将镜像改到自己的账户名下(tag命令会生成一个新的镜像)
#docker image tag 镜像名：版本 账户名/自己起的名字:自己写的版本
docker image tag diytomcat:0.1 账户名/diytomcat:0.1
#然后把生成的新的镜像push
docker push 账户名/diytomcat:0.1

#上传成功！
[root@contos7 ~]# docker push 18239432xxx/diytomcat:0.1
The push refers to repository [docker.io/18239432174/diytomcat]
b66cfcd4e406: Layer already exists
d2b5579aad7b: Layer already exists
eb14e90b8576: Pushed
8fde005537ac: Layer already exists
174f56854903: Layer already exists
0.1: digest: sha256:f622c8f2a4fbe510da142431244c3fa36d6d79130315e9b967fb70c13d224d97 size: 1373
[root@contos7 ~]#

发布镜像到阿里云镜像服务上

发布镜像到阿里云镜像服务上

  1. 登录阿里云
  2. 找到容器镜像服务
  3. 找到实例列表点击个人版进入管理页面
  4. 创建命名空间（czy-docker-test）
  5. 创建镜像仓库，就会得到详细的发布镜像文档(czy-diy-tomcat)
#登录
docker login --username=用户名 registry.cn-hangzhou.aliyuncs.com

#从Registry中拉取镜像
docker pull registry.cn-hangzhou.aliyuncs.com/czy-docker-test/czy-diy-tomcat:[镜像版本号]

#将镜像推送到Registry
docker login --username=用户名 registry.cn-hangzhou.aliyuncs.com
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/czy-docker-test/czy-diy-tomcat:[镜像版本号]
docker push registry.cn-hangzhou.aliyuncs.com/czy-docker-test/czy-diy-tomcat:[镜像版本号]

Docker小结

image-20220720153759248.png 
docker save -o 目标路径 #打成压缩包
docker load -i 压缩包路径 #解压压缩包

Docker网络（学习这个是为了容器编排 和集群部署）

理解Docker网络

测试

#查看ip
ip addr
image-20220720165746577.png

三个网络

#问题：docker如何处理容器的网络访问的？
image-20220721142334070.png 
#启动一个tomcat 查看它的ip
docker run -d -P --name tomcat-ip-addr tomcat:9.0

#直接执行ip addr命令（如果执行不了，先直接进入容器执行apt update && apt install -y iproute2 && apt install -y net-tools &&  apt install -y iputils-ping 命令下载ip addr一些相关的命令）
docker exec -it tomcat-ip-addr ip addr

#查看容器的内部网络地址 ip addr,发现容器启动的时候会得到一个eth0@if11 ip地址，docker分配的
root@774441fe0075:/usr/local/tomcat# ip addr
1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
10: eth0@if11:  mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:ac:11:00:03 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.3/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
root@774441fe0075:/usr/local/tomcat# read escape sequence
[root@contos7 ~]#

思考：liunx能不能ping通容器内部？

#外部虚拟机可以ping通容器内部
[root@contos7 ~]# ping 172.17.0.3
PING 172.17.0.3 (172.17.0.3) 56(84) bytes of data.
64 bytes from 172.17.0.3: icmp_seq=1 ttl=64 time=0.032 ms
64 bytes from 172.17.0.3: icmp_seq=2 ttl=64 time=0.041 ms
64 bytes from 172.17.0.3: icmp_seq=3 ttl=64 time=0.043 ms
64 bytes from 172.17.0.3: icmp_seq=4 ttl=64 time=0.044 ms

#容器内部是可以ping通外部虚拟机
root@774441fe0075:/usr/local/tomcat# ping 10.0.0.120
PING 10.0.0.120 (10.0.0.120) 56(84) bytes of data.
64 bytes from 10.0.0.120: icmp_seq=1 ttl=64 time=0.037 ms
64 bytes from 10.0.0.120: icmp_seq=2 ttl=64 time=0.057 ms
64 bytes from 10.0.0.120: icmp_seq=3 ttl=64 time=0.055 ms
64 bytes from 10.0.0.120: icmp_seq=4 ttl=64 time=0.048 ms
64 bytes from 10.0.0.120: icmp_seq=5 ttl=64 time=0.048 ms
64 bytes from 10.0.0.120: icmp_seq=6 ttl=64 time=0.046 ms
64 bytes from 10.0.0.120: icmp_seq=7 ttl=64 time=0.046 ms

原理：

  1. 我们每启动一个docker容器，docker就会给容器分配一个ip,我们只要安装了docker，就会有一个网卡docker0桥接模式，使用的技术是veth-pair技术。

再次测试ip addr

image-20220727124456608.png

2.再启动一个容器测试，发现又多了一对网卡

image-20220727125008800.png

3.容器里面的网卡地址和外部虚拟机的网卡地址是相对应的。

image-20220727132045373.png 
#我们发现这个容器带来网卡都是一对一对的，这就是evth-pair技术。
#evth-pair就是一对的虚拟设备接口，它们都是成对出现的，一段连着协议，一段彼此连接
#正因为这个特性，veth-pair充当一个桥梁，连接各种虚拟的网络设备的
#OpenStac,Docker容器之间的连接，OVS的连接，都是使用veth-pair技术

思考：如果启动tomcat01和tomcat02，这两个容器是否能ping通呢？

image-20220802170230129.png 
结论：容器和容器之间是可以ping通的。

图解：

image-20220816132049794.png

结论：tomcat01和tomcat02是公用的一个路由器，docker0

所有的容器不指定网络的情况下，都是docker0来路由的，docker0会给我们的容器分配一个默认的可用IP。

小结

Docker使用的是Linux的桥接，宿主机中是一个Docker容器的网桥 docker0。Docker中所有的网络接口都是虚拟的。虚拟的转发效率高。

思考一个场景，我们编写了一个微服务，database url=ip,项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以通过名字来进行访问容器？

--link(已经算是特别老的一个技术了)

--link

[root@contos7 ~]# docker exec -it tomcat03 ping tomcat02
ping: tomcat-ip-addr: Name or service not known

#如何解决这个问题？(通过服务命来ping通)
docker ps -d -P --name tomcat03 --link tomcat02 tomcat-addr:1.0
image-20220816160527738.png

思考：tomcat03已经可以根据名称来ping通tomcat02了，那么tomcat02可以通过同样的方式直接来ping通tomcat03吗？反向ping通

#是不可以的
[root@contos7 ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

我们来查看一些网络信息

#这个bridge就是docker0
[root@contos7 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
46447b6d13a9   bridge    bridge    local
de3768319047   host      host      local
194e79b3702c   none      null      local
[root@contos7 ~]# docker network inspect 46447b6d13a9
[
    {
        "Name": "bridge",
        "Id": "46447b6d13a9134a2787b6f4d1b58ce7771207a681bc726bc2e22f5ced809ad2",
        "Created": "2022-08-16T12:54:39.86976513+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    #可生成的网卡次数255*255
                    "Subnet": "172.17.0.0/16",
                    #docker0
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        
        #这里就能看到网络的配置
        "Containers": {
            "1d40c549a78a8d67c71712b6701b499f0bfb9efbb5c0993c06c9da5909a2bf1d": {
                "Name": "cool_lamport",
                "EndpointID": "9bee8ee5d816dd2db5e3049f1a88765ec6fa24fd4471af780a44cb0230042213",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            },
            "6a7c34f4e9d9b7e21947ac802b05e867b05615733bd36b27bd8f56ad4f3c8fb9": {
                "Name": "tomcat03",
                "EndpointID": "d395028e15c995f5f7adc5cb49ec7b57b44911a061b632c24593844384360b34",
                "MacAddress": "02:42:ac:11:00:05",
                "IPv4Address": "172.17.0.5/16",
                "IPv6Address": ""
            },
            "b2588f56f423b2f4e87c305815094421b232477a54b5caca16ecc66529ec86ca": {
                "Name": "tomcat01",
                "EndpointID": "9877f4d8fd632df7366951d3b4d83300e0703b36efdef4556081ad9d6c3dbf4b",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            },
            "bd9556fad5944928b9b85448e2e183d3b94cf3b3536e785e6295c9003ecf0f8c": {
                "Name": "tomcat02",
                "EndpointID": "2de436550536855821bec0c1a4ce88dbc6d42ae280065d3ca1f3c321cad71b02",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

我们去查看一下tomcat03的hosts文件，发现tomcat02被写死在tomcat03的hosts配置中。我们ping tomcat02就会直接转到写死的地址。

[root@contos7 ~]# docker exec -it 6a7c34f4e9d9 cat /etc/hosts
127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.4      tomcat02 bd9556fad594
172.17.0.5      6a7c34f4e9d9

本质探究：--link就是我们在hosts配置中增加一个172.17.0.4 tomcat02映射。

我们现在玩Docker已经不建议使用--link了！

自定义网络！不使用docker0！

docker0问题：它不支持容器名连接访问！

自定义网络

容器互联：

查看所有的docker网络

image-20220819101610840.png

网络模式

  • bridge:桥接模式，docker默认
  • none:不配置网络
  • host:和宿主机共享网络
  • container:容器网络联通（用的少！局限很大）

测试

#我们直接启动的命令默认是带 --net bridge,而这个就是我们的docker0
docker run -d --name tomcat01 tomcat
docker run -d --name tomcat01 --net bridge tomcat

#docker0特点：默认的，域名是不能访问的  --link可以打通连接

#我们可以自定义一个网络
#--drvier bridge 
#--subnet 192.168.0.0/16 子网掩码
#--gateway 192.168.0.1   路由
[root@contos7 ~]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

[root@contos7 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
46447b6d13a9   bridge    bridge    local
de3768319047   host      host      local
f583b3d99247   mynet     bridge    local
194e79b3702c   none      null      local
[root@contos7 ~]# docker network inspect f583b3d99247
[
    {
        "Name": "mynet",
        "Id": "f583b3d99247db790926d16e2c2e8b531844c6b8dfdb1f0933c5ca7da5739433"                                                                               ,
        "Created": "2022-08-19T14:02:54.824931392+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

#启动2个tomcat容器指定自己创建的网络
docker run -it -P --name tomcat-net-01 --net mynet tomcat-addr:1.0
docker run -it -P --name tomcat-net-02 --net mynet tomcat-addr:1.0

#查看自定义网络的inspect,此时返现了上面启动的两个容器

[root@contos7 ~]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
46447b6d13a9   bridge    bridge    local
de3768319047   host      host      local
f583b3d99247   mynet     bridge    local
194e79b3702c   none      null      local
[root@contos7 ~]# docker network inspect f583b3d99247
[
    {
        "Name": "mynet",
        "Id": "f583b3d99247db790926d16e2c2e8b531844c6b8dfdb1f0933c5ca7da5739433",
        "Created": "2022-08-19T14:02:54.824931392+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "120435c6edb1b0fba91f011c97866e80ef8b12755b2151e776ff824121581fad": {
                "Name": "tomcat-net-02",
                "EndpointID": "4eab8eb6192c5b70d7b3a05535e5a5b247667d3fa6f2dd928888a52136a361de",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "3aa36e61f4c9fc8eb1053d423c67574f1cc9881d4c8651ca795be4e54750dbf3": {
                "Name": "tomcat-net-01",
                "EndpointID": "06af461eb7cecfd04e218f590d683ff1ef7b80eaa077a62a6506d3db9a250aab",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]

#再次测试ping连接
[root@contos7 ~]# docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.084 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.073 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.056 ms
#发现现在不使用--link就可以直接ping名字了

我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐我们平时这样使用网络。

好处：

  • redis:不同的集群使用不同的网络，保证集群是健康和安全的。
  • mysql:不同的集群使用不同的网络，保证集群是健康和安全的。

网络连通

问题：

image-20220819143626016.png 
#在docker0上启动一个tomcat01和tomcat02
[root@contos7 ~]# docker run -it -P --name tomcat01 tomcat-addr:1.0 /bin/bash
[root@contos7 ~]# docker run -it -P --name tomcat02 tomcat-addr:1.0 /bin/bash

测试一下tomcat01是否能ping通tomcat-net-01

#很显然是失败的
[root@contos7 ~]# docker exec -it tomcat01 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known
[root@contos7 ~]#

那么如何打通呢?

image-20220819144359476.png 
#测试打通tomcat01到mynet
[root@contos7 ~]# docker network connect mynet tomcat01

查看mynet的网络情况，发现多出来一个网卡

image-20220819145027185.png

再次测试

#发现已经可以ping通了
[root@contos7 ~]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.097 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.108 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.052 ms

#但tomcat02没有跟mynet网卡打通所以依然ping不通
[root@contos7 ~]# docker exec -it tomcat02 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known

连通之后就是将tomcat01加到了mynet里。

一个容器两个ip地址。

实战：部署一个Redis集群

image-20220819154212798.png 
#创建网卡
docker network create redis --subnet 172.38.0.0/16

#通过脚本创建6个redis配置
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 创建结点1
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#创建结点2
docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#创建结点3
docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#创建结点4
docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#创建结点5
docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
#创建结点6
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

# 创建集群
[root@iZ2zeg4ytp0whqtmxbsqiiZ ~]# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf
/data # redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   slots: (0 slots) slave
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

测试

/data # redis-cli -c
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3      #集群数量3主3从
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:185
cluster_stats_messages_pong_sent:192
cluster_stats_messages_sent:377
cluster_stats_messages_ping_received:187
cluster_stats_messages_pong_received:185
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:377

#带master的是主机 slave是从
127.0.0.1:6379> cluster nodes
86350050c868cf493f5c6f0d85f98fa83d2f1486 172.38.0.14:6379@16379 slave 265a14c372006254d095b536b8e21c7b3b4f460f 0 1660897138206 4 connected
265a14c372006254d095b536b8e21c7b3b4f460f 172.38.0.13:6379@16379 master - 0 1660897137000 3 connected 10923-16383
22ebe278b34ec776dd501a83a1f2f6fad77c2b6c 172.38.0.15:6379@16379 slave 4564e0c5082c8fb6f1452fdbf29662a9614ce906 0 1660897137186 5 connected
4564e0c5082c8fb6f1452fdbf29662a9614ce906 172.38.0.11:6379@16379 myself,master - 0 1660897136000 1 connected 0-5460
6359a5329407ce04d2d6c2e223cf6e49aa0174b7 172.38.0.12:6379@16379 master - 0 1660897137000 2 connected 5461-10922
897beda638e7556b8c3bdfcabf7c487ccd20bb97 172.38.0.16:6379@16379 slave 6359a5329407ce04d2d6c2e223cf6e49aa0174b7 0 1660897137000 6 connected

#set一个值发现处理这个命令的是172.38.0.13:6379这个主机
127.0.0.1:6379> set a b
-> Redirected to slot [15495] located at 172.38.0.13:6379
OK
172.38.0.13:6379>

#此时关闭redis-3,再去获取get a 则是14的redis来处理这个命令，然后再次 cluster nodes会发现14变成了master,13启动后成为了从

我们使用了docker之后，所有的技术都会满满的变得简单起来！

SpringBoot打包成Docker镜像

  1. 构建springboot项目
  2. 打包应用
  3. 编写DockerFile
  4. 构建镜像
  5. 发布运行！
FROM java:8

COPY *.jar /app.jar

CMD ["--server.port=7002"]

EXPOSE 7002

ENTRYPOINT ["java","-jar","/app.jar"]

然后把两个文件扔到虚拟机上，然后打包成镜像就可以启动了，但要注意端口的指定（假如你是run -P 随机指定端口，访问的时候要访问docker映射的端口号）

docker build -f 文件 -t xxx:版本号

你可能感兴趣的:(记录一次Docker的学习)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 关于沟通这件事，项目经理不需要每次都面对面进行 流程大师兄
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 javaUIlinuxPHPandroid
    ╔-----------------------------------╗┆                           
  • zookeeper admin 笔记 braveCS zookeeper
      Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘   数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
  • Spring配置多个连接池 easterfly spring
    项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置：     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"   &nb
  • Mysql 171815164 mysql
    例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
  • CommonDAO（公共/基础DAO） g21121 DAO
            好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。         DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
  • 直言有讳 永夜-极光 感悟随笔
      1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313   精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
  • 安装CentOS 7 和Win 7后，Win7 引导丢失 随便小屋 centos
    一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。 一、首先具有root 的权限。      即进入Terminal后输入命令su，然后输入密码即可 二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
  • Oracle备份与恢复案例 aijuans oracle
    Oracle备份与恢复案例 一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
  • JavaEE开源快速开发平台G4Studio v5.0发布 無為子
      我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。   访问G4Studio网站 http://www.g4it.org   2013-04-06 发布G4Studio_V5.0版本 功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
  • Oracle显示根据高考分数模拟录取 百合不是茶 PL/SQL编程oracle例子模拟高考录取学习交流
    题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选     1,创建student表,和result表 学生信息表; create table student( student_id number primary key,--学生id
  • 优秀的领导与差劲的领导 bijian1013 领导管理团队
    责任 优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。 差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。 努力工作 优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
  • js函数在浏览器下的兼容 Bill_chen jquery浏览器IEDWRext
      做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同：   IE6：node.nextSibling,对于FF是不能识别的；   FF：node.nextElementSibling,对于IE是不能识别的； 兼容解决方式：var Div = node.nextSibl
  • 【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
    吞吐量与用户线程暂停时间   衡量垃圾回收算法优劣的指标有两个： 吞吐量越高，则算法越好 暂停时间越短，则算法越好 首先说明吞吐量和暂停时间的含义。   垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
  • J2EE监听器和过滤器基础 白糖_ J2EE
    Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。 监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。   ServletContex监听器 ServletContex又叫application
  • 博弈AngularJS讲义(16) - 提供者 boyitech jsAngularJSapiAngularProvider
      Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。   那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
  • java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
    public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
  • sqlserver 2000 无法验证产品密钥 Chen.H sqlwindowsSQL ServerMicrosoft
    在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
  • [新概念武器]气象战争 comsci
           气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织....        原因如下:        地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
  • oracle 中 rollup、cube、grouping 使用详解 daizj oraclegroupingrollupcube
    oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景    --- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL)   
  • 技术资料汇总分享 Dead_knight 技术资料汇总 分享
    本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
  • 初一下学期难记忆单词背诵第一课 dcj3sjt126com englishword
    could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
  • 截取视图的图片, 然后分享出去 dcj3sjt126com OSObjective-C
    OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
  • MySql重置密码 fanxiaolong MySql重置密码
    方法一:  在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库  然后进入mysql mysql>use mysql;  mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
  • Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcacheMemoryStoreDiskStore存储驱除策略
    Ehcache中储存缓存的方式   目录 1     堆内存（MemoryStore） 1.1     指定可用内存 1.2     驱除策略 1.3     元素过期 2   &nbs
  • spring mvc中的@propertysource jackyrong spring mvc
      在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource  在spring 3.1中开始引入 比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中   @PropertySource(&
  • 重学单例模式 lanqiu17 单例Singleton模式
    最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。 第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。 单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式 静态内部类方式: package test.pattern.singleton.statics; publ
  • .NET开源核心运行时，且行且珍惜 netcome java.net开源
    背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
  • 使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web高并发oscahe缓存
    此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。   缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
  • Spring+Mybatis 手动控制事务 toknowme mybatis
    @Override    public boolean testDelete(String jobCode) throws Exception {       boolean flag = false;  &nbs
  • 菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
    熟悉Android开发架构和API调用 掌握APP适应不同型号手机屏幕开发技巧 熟悉Android下的数据存储  熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具  熟悉Android框架原理及Activity生命周期 熟练进行Android UI布局 熟练使用SQLite数据库； 熟悉Android下网络通信机制，S
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他