Docker 虚拟化技术学习笔记

这是根据B站 遇见狂神说 Docker 的学习笔记

需要学习的Docker的技术

  • Docker概述

  • Docker安装

  • Docker命令

    • 镜像命令
    • 容器命令
    • 操作命令
  • Docker镜像

  • Docker数据卷

  • DockerFile

  • Docker网络原理

  • IDEA中整合Docker

  • Docker Compose(集群)

  • Docker Swarm

  • CI\CD jenkins

Docker 虚拟化技术学习笔记_第1张图片

注意事项:

在win10中安装docker的时候,会自动启用hyperV,但VMware无法使用HyperV启动虚拟机,会导致虚拟机无法使用

解决方法:

  • 当使用Docker For Window,且不使用VMware时,请以管理员身份运行PowerShell,并输入 命令:

    bcdedit /set hypervisorlaunchtype auto
    

    然后重启电脑;此时Docker For Window运行Ok。

  • 当需要WMware而不是用Docker For WIndow时,请以管理员身份运行PowerShell,并输入 命令:

    bcdedit /set hypervisorlaunchtype off 
    

    回车,然后重启电脑;此时WMware运行Ok。

每次修改后都得需要重启电脑,这么麻烦,那我还是直接在虚拟机使用docker吧,哈哈

Docker 概述

Docker为什么会出现:

为了解决“在我的电脑上运行是正常的”等问题,解决程序在不同环境中出现的问题

传统的部署方式:开发jar包,运维来部署

现在的部署方法:开发打包部署上线,一套流程就可以完成整个部署过程

Docker 解决的问题:

JRE:多个应用之间可能会有端口冲突,使用Docker安装即可用(Tomcat、mysql等内容)

隔离:Docker的核心思想,每个箱子是相互隔离的

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

虚拟机:在一台电脑上使用虚拟机软件虚拟出多台电脑中;虚拟机也是属于虚拟化技术,也是一种虚拟化技术。

容器:隔离,镜像(最核心的镜像一般都很小,一般是4M左右)

Docker是基于Go语言开发的,

docker官方网站:https://www.docker.com/

Docker的文档地址:https://docs.docker.com/

Docker的仓库地址:https://hub.docker.com/

Docker能做些什么

虚拟机的缺点:

  1. 资源占用十分多
  2. 冗余步骤多
  3. 启动很慢

容器化技术:并不是模拟的整个操作系统,而是形成一个个容器,相互之间互不干扰

虚拟机和容器的比较:

  • 传统的虚拟机模拟的是整个硬件换件,然后在这个系统上安装和运行软件
  • 容器内容的应用直接运行在宿主机中,容器没有自己的内核,也不模拟硬件,占用的资源小
  • 容器之间相互隔离,每个容器中都有一个属于自己的文件系统,互不影响

DevOps(开发、 运营):应用更加快捷的交付和部署

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

更加便捷的升级和扩缩容

更加简单的系统运维

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

更加高效的计算资源利用

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

Docker的安装

Docker的基本组成

Docker 虚拟化技术学习笔记_第2张图片

镜像(image):

docker 镜像是一个模板,通过这个模板创建容器服务,通过这个镜像可以创建多个容器(最终服务运行和项目运行都是在容器中)

容器:

Docker利用容器技术,独立运行一个或者一组应用,通过镜像来创建,容器可以理解为一个精简版的虚拟机系统。

仓库:

仓库就是用来防止镜像的地方,(就像 git的仓库)

仓库同样分为公有仓库和私有仓库,默认的仓库是位于国外的,国内可以使用阿里云容器服务器。

安装Docker

环境准备:

1、 需要Linux基础

2、 需要Linux环境

安装

  1. 卸载旧版本的Docker,Docker需要centos版本以上的Linux内核

     sudo yum remove docker \
                      docker-client \
                      docker-client-latest \
                      docker-common \
                      docker-latest \
                      docker-latest-logrotate \
                      docker-logrotate \
                      docker-engine
    
  2. 安装软件

    sudo yum install -y yum-utils
    
  3. 设置镜像仓库

    # 国外版的仓库镜像,速度十分缓慢
    sudo yum-config-manager \
        --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
        
    # 阿里云版本的镜像,速度较为快一些
    sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
  4. 安装Docker引擎

    docker-ce : 社区版本 docker-ee:商业版

    # 更新到最新版本
    sudo yum makecache fast
    # 安装docker-ce
    sudo yum install docker-ce docker-ce-cli containerd.io
     
     # 或者安装指定版本的docker版本
     sudo yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
    
  5. 启动docker

    systemctl start docker
    
    • 使用docker version查看具体的docker版本信息
    [root@centos-2 ~]# docker version
    Client: Docker Engine - Community
     Version:           19.03.12
     API version:       1.40
     Go version:        go1.13.10
     Git commit:        48a66213fe
     Built:             Mon Jun 22 15:46:54 2020
     OS/Arch:           linux/amd64
     Experimental:      false
    
    Server: Docker Engine - Community
     Engine:
      Version:          19.03.12
      API version:      1.40 (minimum version 1.12)
      Go version:       go1.13.10
      Git commit:       48a66213fe
      Built:            Mon Jun 22 15:45:28 2020
      OS/Arch:          linux/amd64
      Experimental:     false
     containerd:
      Version:          1.2.13
      GitCommit:        7ad184331fa3e55e52b890ea95e65ba581ae3429
     runc:
      Version:          1.0.0-rc10
      GitCommit:        dc9208a3303feef5b3839f4323d9beb36df0a9dd
     docker-init:
      Version:          0.18.0
      GitCommit:        fec3683
    
    
  6. 运行docker hello world

    首先判断是否存在这个镜像,如果不存在,那么从远程仓库中拉取hello-world仓库

    # docker run hello-world
    

Docker 虚拟化技术学习笔记_第3张图片

  1. 查看下载的镜像

    docker images
    

  1. 卸载docker镜像

    1. 卸载安装的软件
    2. 移除安装目录
    sudo yum remove docker-ce docker-ce-cli containerd.io
    sudo rm -rf /var/lib/docker
    

Docker的底层原理

Docker如何工作的

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

DockerServer接收到Docker-Client指令,会执行这个指令!

Docker 虚拟化技术学习笔记_第4张图片

Docker为什么比虚拟机快?

1、Docker有比虚拟机更少的抽象层

2、Docker利用的是宿主机的内核,vm需要的是Guest OS,

所以说,新建一个容器的时候,docker不需要像虚拟机一样重新加载一个操作系统的内核,避免引导。虚拟机加载Guest Os,运行时间是分钟级别的;docker是利用宿主机的操作系统,忽略了这个复杂的过程,运行时间是秒级的。

Docker 虚拟化技术学习笔记_第5张图片

Docker 的基础命令

帮助命令

docker version 	#显示docker的版本信息
docker info		# 显示docker的系统信息,包括镜像和容器的数量
docker --help 	# 帮助命令

镜像命令

docker images

使用帮助命令查看所有的images命令

# docker images --help

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

List images

Options:
  -a, --all             # 列出所有的镜像
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print images using a Go template
      --no-trunc        Don't truncate output
  -q, --quiet           # 只显示镜像id
  1. docker images 命令

    # docker images
    REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
    hello-world         latest              bf756fb1ae65        6 months ago        13.3kB
    
    
    ========================命令解释=====================
    REPOSITORY: 镜像的仓库
    TAG:镜像的标签
    IMAGE ID:镜像的id
    CREATED:镜像的创建时间
    SIZE:镜像的大小
    
    
    
  2. docker search 搜索镜像

    help列出所有的可选命令

    [root@centos-2 ~]# docker search --help
    
    Usage:	docker search [OPTIONS] TERM
    
    Search the Docker Hub for images
    
    Options:
      -f, --filter filter   Filter output based on conditions provided
          --format string   Pretty-print search using a Go template
          --limit int       Max number of search results (default 25)
          --no-trunc        Don't truncate output
    
    

    查找mysql

    [root@centos-2 ~]# docker search mysql
    NAME                              DESCRIPTION                                     STARS               OFFICIAL            AUTOMATED
    mysql                             MySQL is a widely used, open-source relation…   9770                [OK]                
    
    
    # 可选项,通过收藏进行过滤
    docker search mysql --filter=STARS=3000		#可以搜索出stars大于3000的选项
    
  3. dockers pull

    help命令

    [root@centos-2 ~]# docker pull --help
    
    Usage:	docker pull [OPTIONS] NAME[:TAG|@DIGEST]
    
    Pull an image or a repository from a registry
    
    Options:
      -a, --all-tags                Download all tagged images in the repository
          --disable-content-trust   Skip image verification (default true)
          --platform string         Set platform if server is multi-platform capable
      -q, --quiet                   Suppress verbose output
    
    

    下载mysql镜像

    # 下载镜像:docker pull 镜像名[:tag]
    [root@centos-2 ~]# docker pull mysql
    Using default tag: latest 		# 如果不写tag,那么默认下载latest
    latest: Pulling from library/mysql	# 
    6ec8c9369e08: Pull complete 	# 分层下载,docker image的核心就是联合文件系统
    177e5de89054: Pull complete 
    ab6ccb86eb40: Pull complete 
    e1ee78841235: Pull complete 
    09cd86ccee56: Pull complete 
    78bea0594a44: Pull complete 
    caf5f529ae89: Pull complete 
    cf0fc09f046d: Pull complete 
    4ccd5b05a8f6: Pull complete 
    76d29d8de5d4: Pull complete 
    8077a91f5d16: Pull complete 
    922753e827ec: Waiting 
    
    
    # 指定版本信息
    [root@centos-2 ~]# docker pull mysql:5.6	#版本号需要在docker仓库中允许
    
  4. 删除命令: docker rmi -f 镜像id

    # 删除单个镜像
     docker rmi -f  镜像id
     
     # 删除多个镜像
     docker rmi -f 镜像id  镜像id  镜像id
     docker rmi -f $(docker images -aq)		#删除所有的镜像
    

容器命令

说明:有了镜像才能创建容器,下载一个centos镜像作为练习

docker pull centos

新建容器并启动

docker run [可选参数] image

# 可选参数
--name Name 	容器名字 Tomcat01等
--d 			后台运行
--it			使用交互模式运行,进入容器查看内容
--p				指定容器端口  -p 8080:8080
	-ip:主机端口:容器端口
	-p 主机端口:容器端口(常用的方式)
	-p 容器端口
-p				随机指定端口

启动主机,主机名就是容器id

[root@centos-2 ~]# docker run -it centos /bin/bash	#这是一个基础的版本,许多命令不存在
[root@397571d3a5ef /]# exit		#退出

查看运行容器的命令:

docker ps	
docker ps -a 		#查看曾经运行过的程序

docker ps全部的命令:

[root@centos-2 ~]# docker ps --help

Usage:	docker ps [OPTIONS]

List containers

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print containers using a Go template
  -n, --last int        Show n last created containers (includes all states) (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display numeric IDs
  -s, --size            Display total file sizes

退出容器

exit   # 停止容器并退出
ctrl + P + q  # 退出容器不停止

删除容器

docker rm 容器id		#删除单个镜像,不能删除正在运行的容器,如果需要强制删除 rm -f
docker rm -f $(docker ps -aq)	#删除所有的进行
docker ps -a -q | xargs docker rm  #删除所有的容器

启动和停止容器

docker start 容器id	#启动容器
docker restart 容器id	#重新启动容器
docker stop 容器id	#停止容器
docker kill 容器id	#杀死容器

Docker的其他命令

后台启动容器:

docker run -d 容器名   #返回容器的id
# 使用docker ps 发现容器停止了
# docker 使用后台运行,必须有一个前台进程,docker发现没有应用会自动停止,

[root@centos-2 ~]# docker run -d centos /bin/sh  -c "while true; do echo hello;sleep 1;done"
3b244f33c79dc16b9f8956405a7c3553df5f01141189bcf0d90228fa17d213bc

查看日志:

docker logs

# 使用help
[root@centos-2 ~]# docker logs --help

Usage:	docker logs [OPTIONS] CONTAINER

Fetch the logs of a container

Options:
      --details        Show extra details provided to logs
  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
      --tail string    Number of lines to show from the end of the logs (default "all")
  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)

查看日志

docker logs -tf --tail 10 容器id

Docker进程信息

显示docker中的进程信息

[root@centos-2 ~]# docker top --help
Usage:	docker top CONTAINER [ps OPTIONS]
Display the running processes of a container

使用方法:

docker top 容器id

Docker 查看容器内部信息

查看容器的内部信息

[root@centos-2 ~]# docker inspect --help

Usage:	docker inspect [OPTIONS] NAME|ID [NAME|ID...]

Return low-level information on Docker objects

Options:
  -f, --format string   Format the output using the given Go template
  -s, --size            Display total file sizes if the type is container
      --type string     Return JSON for specified type

使用命令:

[root@centos-2 ~]# docker inspect 3b244f33c79d
[
    {
        "Id": "3b244f33c79dc16b9f8956405a7c3553df5f01141189bcf0d90228fa17d213bc",
        "Created": "2020-07-27T23:14:11.789091289Z",
        "Path": "/bin/sh",
        "Args": [
            "-c",
            "while true; do echo hello;sleep 1;done"
        ],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
.....

进入当前运行的容器的命令

容器一般使用后台方式运行,需要进入容器,修改一些设置

[root@centos-2 ~]# docker exec --help

Usage:	docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Run a command in a running container

Options:
  -d, --detach               Detached mode: run command in the background
      --detach-keys string   Override the key sequence for detaching a container
  -e, --env list             Set environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format: <name|uid>[:<group|gid>])
  -w, --workdir string       Working directory inside the container

进入之前的centos

[root@centos-2 ~]# docker exec -it 3b244f33c79d /bin/bash
[root@3b244f33c79d /]#    		#这里的系统名称就看出来,已经进入了docker容器中

第二个进入容器中的命令:attach

[root@centos-2 ~]# docker attach --help

Usage:	docker attach [OPTIONS] CONTAINER

Attach local standard input, output, and error streams to a running container

Options:
      --detach-keys string   Override the key sequence for detaching a container
      --no-stdin             Do not attach STDIN
      --sig-proxy            Proxy all received signals to the process (default true)

和exec不同的是,attach进入的是正在运行的命令行,即正在打印hello的命令行;

exec是打开了一个新的命令行

[root@centos-2 ~]# docker attach 1428eeb235f7
hello
hello
hello
.......

Docker 从容器内拷贝到主机上

[root@centos-2 ~]# docker cp --help

Usage:	docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-
	docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH

Copy files/folders between a container and the local filesystem

Use '-' as the source to read a tar archive from stdin
and extract it to a directory destination in a container.
Use '-' as the destination to stream a tar archive of a
container source to stdout.

Options:
  -a, --archive       Archive mode (copy all uid/gid information)
  -L, --follow-link   Always follow symbol link in SRC_PATH

首先运行容器,在容器的/home中新建1.txt文件,回到主机中,使用ps查看容器的id(不管容器是启动还是关闭,只要能够拿到容器id,就可以拿到数据),

# 将容器/home/1.txt 复制到主机的 /home目录下
docker cp a7a9957c2027:/home/1.txt /home

小结

Docker 虚拟化技术学习笔记_第6张图片

Docker命令练习

1. 安装nginx

1. 搜索镜像: docker search nginx
2. 安装镜像: docker pull nginx
3. 查看是否下载成功:	docker images
4. 运行nginx,并将容器的80端口映射到本机端口号3344, -name 重新命名  ;	
	docker run -d --name nginx01 -p 3344:80 nginx

5. 测试: curl localhost:3306

如果每次更改配置文件,都需要进入容器内部;可以使用一个映射路径,在这个映射路径中修改文件,在容器内部会自动修改(数据卷技术)

2.安装Tomcat

# 1. 搜索Tomcat版本:

# 官方的使用
docker run -it --rm tomcat:9.0
# 之前使用的是停止容器后容器依然存在, docker run -it --rm ,一般用来测试,用完即删

#1,安装Tomcat
	docker  pull tomcat:9.0
# 启动Tomcat容器
	docker run -d -p 3355:8080 --name tomcat01 tomcat
# 进入容器
	docker exec -it tomcat01 /bin/bash
	# 发现的问题:1、Linux命令少了, 2.没有webapps中的内容
	# 原因是:默认的选择最小的镜像,剔除不必要的部分,保证最小可运行环境即可

部署Es+Kibana

es 暴露的端口很多,十分耗内存,es的数据一般需要放置在安全的目录下:挂载

# 
docker run -d --name elasticsearch  -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 非常占内存,使用docker stats 查看cpu的状态

可视化工具

  • portainer

    docker run -d -p 8080:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
    
    

什么portainer

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

-v 是挂载命令,将容器挂载到主机上面

Docker镜像原理

镜像是什么

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

所有的应用都是直接打包成docker镜像,就可以直接跑起来!

如何得到镜像:

  • 从远程仓库中下载
  • 朋友拷贝
  • 自己制作一个DockerFile文件

Docker镜像加载原理

UnionFs (联合文件系统)

我们下载的时候看到的一层层文件就是这种原理!

UnionFs (联合文件系统):Union文件系统是一种分层、轻量级并且高性能的文件系统,它支持对文件的修改作为一次提交来一层层的叠加,同时也可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。镜像又可以通过分层来进行继承,基于基础镜像(无父镜像),可以制作各种具体应用的镜像。

特性:一次同时加载多个文件系统,但是从外边看起来,只能看到一个文件系统,联合加载会把各层文件系统都叠加起来,这样最终的文件系统会包含所有的底层文件和目录.

Docker镜像加载原理

docker的镜像就是实际上有一层一层的文件系统所组成的,这种层次的文件系统UnionFs.

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 /prpc /bin /etc等标准的目录和文件。rootfs就是各种不同的操作系统的发行版本,例如Ubuntu和centos等

Docker 虚拟化技术学习笔记_第7张图片

docker中安装的系统是一个精简的os,rootfs的体积可以很小,只需要包含基本的命令,工具和程序库就可以了,因为底层直接用HOST的kernel,自己只需要提供rootfs就可以了。由此可见对于不同的Linux发行版,rootfs都是基本一致的。因此不同的发行版本可以公用bootfs。

分层原理

我们在下载镜像的时候,发现镜像都是分层下载的

理解:

所有的docker镜像都有一个基础的镜像层,将进行修改或者增加新的内容时,就会在当前镜像上创建一个新的镜像层。例如使用Ubuntu创一个镜像,位于新镜像的第一层;如果在该镜像中添加Python包,就会在该基础镜像层上创建第二个镜像层;如果继续添加安全补丁,就会创建第3个镜像层。

Docker 虚拟化技术学习笔记_第8张图片

在添加额外的镜像层的同时,竞相始终是当前所有镜像的集合,例如下图中的例子,每个镜像底层包含3个文件,而镜像中包含了来自两个镜像层的6个文件

Docker 虚拟化技术学习笔记_第9张图片

如果是在底层的镜像总有文件需要更新,直接将更新的文件加在镜像层,这样在外边看起来文件的总数还是不变的,例如上面中文件5有一个更新为文件7,文件7位于第3层镜像层,但是在外面看来,这个镜像还是6个文件

Docker 虚拟化技术学习笔记_第10张图片

Docker通过存储引擎(新版本采用快照机制)方式实现镜像层堆栈,并保证多镜像层对外展示为统一的文件系统。

Linux上可用的存储引擎有AFUS、Overlay2、 Device Mapper、 Btrfs以及ZFS。顾名思义,每种存储引擎都是基于Linux中对应的文件系统或者是块设备技术,并且每种存储结构都有其独特的性能特点。

Docker在Window上仅支持windowsfilter一种存储引擎,该引擎基于NTFS文件系统之上实现了分层和Cow。

下面展示的是与系统显示相同的3层镜像。所有的镜像层堆叠并合并,对外展示统一的视图

Docker 虚拟化技术学习笔记_第11张图片

特点

Docker镜像都是只读的,当容器启动时,一个新的可写层就被加载到了镜像的顶部!这一层就是我们通常所说的容器层,容器之下都叫镜像层。

Commit 镜像

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

容器数据卷

什么是容器数据卷

数据:如果数据都在容器中,如果我们把容器删除了,那么数据就会被删除!需求:数据可以持久化

容器之间可以有一个数据共享技术,Docker容器中产生的数据,同步到本地中。这就是卷技术,目录的挂载,将我们容器内的目录挂载到Linux上面。

Docker 虚拟化技术学习笔记_第12张图片

总结:容器的持久化和同步操作,容器之间也是可以共享数据的

使用卷技术

方法一: 使用命令挂载:-v

docker run -it -v 主机目录:容器内目录

将centos容器内部的/home目录挂载到主机的/home/test目录下面

docker run -it -v /home/test:/home centos /bin/bash

使用docker inspect查看容器内部的信息:

Docker 虚拟化技术学习笔记_第13张图片

容器内文件夹和主机的文件夹将会同步。同步是一个双向的过程。

实战:Mysql数据同步

mysql的持久化问题;

步骤:

# 1. 搜索mysql
	docker search mysql
# 2. 安装mysql
	docker pull mysql:5.7
# 3. 启动mysql,启动的时候将配置文件和数据文件映射到主机中,并且使用 -e 配置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.7

具名挂载和匿名挂载

匿名挂载:
-v 容器内目录
docker run -d -P --name nginx01 -v /etc/nignx nginx

# docker volume 命令查看docker中的数据卷
[root@centos-2 test]# docker volume --help
Usage:	docker volume COMMAND
Manage volumes
Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove all unused local volumes
  rm          Remove one or more volumes
Run 'docker volume COMMAND --help' for more information on a command.


# 查看所有的volume的情况
[root@centos-2 test]# docker volume ls
DRIVER              VOLUME NAME
local               f32fb32afe3ffa1b3c691af07adc7b244ae225142f44849316bef56e0f69b826

# 这里发现,这种就是匿名挂载, -v的时候只写了容器内的名字没有写容器外的名字

具名挂载:(经常使用的)

就是在 -v 卷名:容器内路径

docker run -d -P --name nginx03 -v nignx-config:/etc/nignx nginx

如果没有指定绝对路径,那么就会在/var/lib/docker/volumes

# 使用命令查看卷挂载的路径
[root@centos-2 test]# docker volume inspect nignx-config
[
    {
        "CreatedAt": "2020-07-28T13:32:36+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/nignx-config/_data",
        "Name": "nignx-config",
        "Options": null,
        "Scope": "local"
    }
]

# 可以看到nignx-config文件被映射到了/var/lib/docker/volumes/目录下

如何区分具名挂载和匿名挂载
-v 容器内路径			 # 匿名挂载
-v 卷名:容器内路径			# 具名挂载
-v /主机路径:容器内路径	   # 主机挂载

拓展
# 通过 -v 容器内路径,ro,rw改变读写权限
ro 	readonly 	# 只读,这个路径只能宿主机来操作,容器内部是无法操作的
rw 	readwrite	# 可读写

# 一旦设定了容器的权限,容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx03 -v nignx-config:/etc/nignx:rw nginx
docker run -d -P --name nginx03 -v nignx-config:/etc/nignx:ro nginx

DockerFile

初识DockerFile

DockerFile 就是用来构建docker镜像的构建文件。是一个命令脚本

在home目录下新建一个docker-file-test文件夹,在文件夹中创建一个文件dockerfile1写入:

# 文件中内容, 指令要大写,这里的每一个命令就是镜像的一层
FROM centos

VOLUME ["volume01", "volume02"]

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


然后执行命令

docker build -f ./dockerfile1 -t lt/centos:0.1 .

[root@centos-2 docker-file-test]# docker build -f ./dockerfile1 -t lt/centos:0.1 .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM centos
 ---> 831691599b88
Step 2/4 : VOLUME ["volume01", "volume02"]
 ---> Running in e7e474ee96b4
Removing intermediate container e7e474ee96b4
 ---> d1ff35b3eb7a
Step 3/4 : CMD echo "-----end-----"
 ---> Running in 1717e5164a2f
Removing intermediate container 1717e5164a2f
 ---> 83d12f6470b9
Step 4/4 : CMD /bin/bash
 ---> Running in 2952add39b0f
Removing intermediate container 2952add39b0f
 ---> 229f3e861101
Successfully built 229f3e861101
Successfully tagged lt/centos:0.1

# 查看是否生成images, 发现已经生成了image
[root@centos-2 docker-file-test]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
lt/centos           0.1                 229f3e861101        20 seconds ago      215MB


启动自己的的镜像

docker run -it 229f3e861101 /bin/bash

Docker 虚拟化技术学习笔记_第14张图片

这个卷一定和主机内的某个目录相对应,而且这两个卷是匿名挂载的

# 使用docker inspect查看该容器的具体信息
[root@centos-2 test]# docker inspect 09714e560694  #容器id

Docker 虚拟化技术学习笔记_第15张图片

这种方法在未来我们将会使用的非常多,因为我们会自己构建我们的镜像,

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

数据卷容器

多个mysql实现数据共享

Docker 虚拟化技术学习笔记_第16张图片

# 父类容器
docker run -it --name docker01  镜像名称

# 子类
docker run -it --name docker02 --volumes-from docker01 镜像名称

#这样子类就会继承了父类容器,数据卷容器同步。
# 如果删除了docker01, 查看文件依然存在,文件是一种双向拷贝的方法

结论:

容器之间配置传递消息,数据卷的生命周期一直持续到没有容器使用为止,但是一旦持久化了本地,本地的数据并不会被删除。

DockerFile 构建

基础知识:

  1. 每个保留关键字必须是大写字母

  2. 指令是从上到下顺序执行的

  3. # 表示注释

  4. 每一个指定都会创建提交一个新的镜像层

    Docker 虚拟化技术学习笔记_第17张图片

dockerfile面向开发,我们以后要发布项目,作镜像,就要编写dockerfile文件,这个文件十分简单!

DockerFile:构建文件,定义了一切的步骤,源代码

DockerImages:通过DockerFile构建生成镜像,最终发布和运行产品

Docker容器:容器就是镜像运行起来提供服务器。

DockerFile 指令

FROM  		#基础镜像,一切从这里开始构建
MAINTAINER		# 镜像是谁写的  姓名+邮箱
RUN			# 镜像构建的时候要运行的命令
ADD			# 步骤:Tomcat镜像,这个Tomcat压缩包!添加内容
WORKDIR		# 镜像的工作目录
VOLUME		# 挂载目录
EXPOSE		# 暴露端口
CMD			# 指定容器运行的时候要运行的命令;只有最后一个有效,可以被取代
ENTERYPOINT	#指定这个容器启动的时候启动的命令,可以追加
ONBUILD		# 当构建一个被继承DockerFile 这个时候就会运行 ONBUILD指令,触发指令
COPY		# 类似于ADD,将我们的文件拷贝到镜像中
ENV			# 构建的时候设置环境变量

Docker 虚拟化技术学习笔记_第18张图片

实战测试:

Docker Hub中的镜像都是从 基础镜像过来的 FROM scratch,然后配置其他的软件

创建一个自己的Centos

FROM centos
MAINTAINER longtao<[email protected]>

ENV MYPATH /usr/local
WORKDIR	$MYPATH

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

CMD echo %MYPATH
CMD echo "====end====="
CMD /bin/bash


通过文件构建镜像

docker build -f mydockerfile -t mycentos:0.1 .

我们可以列出本地的镜像的变更历史

docker history 镜像id

DockerFile 创建一个tomcat

  1. 准备镜像文件 Tomcat压缩包, jdk压缩包

  2. 编写DockerFile文件 官方命名 Docker,build的时候会自动寻找这个文件,就不需要使用 -f指定

    FROM centos
    MAINTAINER longtao<[email protected]>
    
    COPY readme /usr/local/readme
    
    ADD apache-tomcat-9.0.37.tar.gz /usr/local
    ADD jdk-8u261-linux-x64.tar.gz /usr/local
    
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    
    ENV JAVA_HOME /usr/local/jdk1.8.0_261
    ENV CLASSPATH $JAVA_HOME/lib
    ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
    ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
    ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
    
    EXPOSE 8080
    CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -f /usr/local/apache-tomcat-9.0.37/logs/catalina.out
    
    
    
  3. 构建镜像

    docker build -t mytomcat
    
    
  4. 启动镜像

  5. 测试镜像

  6. 发布项目

发布镜像

DockerHub

  1. 注册账号

  2. 确定这个账号可以登录

    docker login -u 用户名 -p 密码
    
    
  3. 登录完成后就可以使用 docker push将镜像发送到docker Hub中

  4. 如果显示没有本地版本,就可以使用tag 更改标签

Docker网络

理解Docker0网络

Docker 虚拟化技术学习笔记_第19张图片

查看docker内部的ip地址

docker exec -it tomcat ip addr


原理

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

  2. 再次启动一个容器,发现又多了一个网卡

    # 我们发现这个容器带来网卡,都是一对一对的
    # evth-pair 就是一对的网络设备接口,他们都是成对出现的,一段连接着协议,一段彼此相连
    # 这个是因为这个特性,evth-pair 充当一个容器,连接着各种虚拟设备
    # OpenStack、Docker容器之间的连接 OVS连接 都是使用evth-pair技术
    
    
  3. docker容器之间可以互相ping通

Docker 虚拟化技术学习笔记_第20张图片

结论:Tomcat01和Tomcat02是共用一个路由器docker0;

所有容器在不指定网络的情况下,都是docker0路由器,docker会给我们的容器分配一个默认的可用的ip

Docker 虚拟化技术学习笔记_第21张图片

Docker网络都是虚拟的,虚拟转发的效率高!(内网传输文件)

只要删除容器,对应的网桥就消失了。

项目不重启,数据ip更换了,我们希望可以处理这个问题,可以通过名字来访问容器?

–link

例如在Tomcat01中ping Tomcat02,但是不知道Tomcat02的ip地址,所以可以使用–link作为一种方法:

docker run  -d -P --name tomcat01 --link tomcat02 tomcat
docker exec -it tomcat01 ping tomcat02	# 现在就可以ping通了
# 反向的ping 可能不通

–link 就是我们在host配置中增加了一个Tomcat02 的信息

自定义网络

[root@centos-2 ~]# docker network --help
Usage:	docker network COMMAND
Manage networks
Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks
Run 'docker network COMMAND --help' for more information on a command.

查看所有的docker网络

Docker 虚拟化技术学习笔记_第22张图片

网络模式:

bridge:桥接模式,在docker上搭建网络连桥

none: 不配置网络

host:主机模式,和宿主机共享网络

container:容器网络连通(用的很少,局限非常大)

测试

我们之前启动的容器中,默认的模式为--net bridge

docker run -it -P --name tomcat01 --net bridge tomcat

docker0的特点,默认,域名不能访问,

自己创建网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

自己创建的网络可以不使用名字就可以访问,自定义的docker都已经帮助我们维护好对应的关系,推荐使用这样的网络。

网络互连

Docker 虚拟化技术学习笔记_第23张图片

# 容器和网络进行连接
docker network connect mynet tomcat01
# 将Tomcat01放入到mynet网络中,一个容器两个ip

实战:部署Redis集群

Docker 虚拟化技术学习笔记_第24张图片

步骤:

  1. 创建网络

    docker network create --subnet 172.38.0.0/16  redis
    
    

你可能感兴趣的:(基础知识,docker,java)