精华内容
参与话题
问答
  • 虚拟化技术

    2020-11-07 17:44:46
    Linux虚拟化技术 常用虚拟化技术 vmware(收费,企业版 esxi ) https://www.proxmox.com/en/proxmox-ve redhat kvm rhev 虚拟化平台安装 查看是否支持虚拟化 [root@localhost ~]# grep -P "vmx|svm" /proc/cpuinfo ...

    Linux虚拟化技术

    常用虚拟化技术

    vmware(收费,企业版 esxi )
    https://www.proxmox.com/en/proxmox-ve
    redhat kvm rhev

    虚拟化平台安装

    查看是否支持虚拟化

    [root@localhost ~]# grep -P "vmx|svm" /proc/cpuinfo
    flags		: ... ... vmx
    [root@localhost ~]# lsmod |grep kvm
    kvm_intel             174841  6 
    kvm                   578518  1 kvm_intel
    irqbypass              13503  1 kvm
    

    创建虚拟机 2cpu,4G内存(base-vm.zip 模板的默认用户名: root 密码: a)
    配置 yum 源,安装 libvirt 软件
    1、把 CentOS-7.5-1804.iso 加载到虚拟机的光驱里
    2、虚拟机里面 mount 该 iso 到 /var/centos-1804
    3、配置 yum 源

    [root@localhost ~]# mkdir -p /var/centos-1804
    [root@localhost ~]# vim /etc/fstab
    dev/cdrom              /var/centos-1804        iso9660 defaults,ro     0 0
    [root@localhost ~]# mount /var/centos-1804
    [root@localhost ~]# vim /etc/yum.repos.d/local.repo
    [CentOS-Base]
    name=CentOS-$releasever - Base
    baseurl="file:///var/centos-1804"
    enabled=1
    gpgcheck=0
    

    4、安装 libvirtd

    [root@localhost ~]# yum install qemu-kvm libvirt-daemon libvirt-client libvirt-daemon-driver-qemu
    [root@localhost ~]# systemctl enable --now libvirtd
    [root@localhost ~]# virsh version
    

    虚拟机组成
    ​ 硬盘文件 /var/lib/libvirt/images/
    ​ 配置文件 /etc/libvirt/qemu/

    虚拟化实验图例

    在这里插入图片描述

    
    #### Linux虚拟机
    
    ###### 虚拟机硬盘磁盘文件
    
    通过xshell上传 cirros.qcow2 到虚拟机
    通过 qemu-img 创建虚拟机磁盘
    格式: qemu-img  子命令  子命令参数  虚拟机磁盘文件  大小
    
    ```shell
    [root@localhost ~]# cp cirros.qcow2 /var/lib/libvirt/images/
    [root@localhost ~]# cd /var/lib/libvirt/images/
    [root@localhost ~]# qemu-img create -f qcow2 -b cirros.qcow2 vmhost.img 30G
    [root@localhost ~]# qemu-img info vmhost.img #查看信息
    
    虚拟网络配置

    虚拟网络管理命令

    命令 说明
    virsh net-list [–all] 列出虚拟网络
    virsh net-start 启动虚拟交换机
    virsh net-destroy 强制停止虚拟交换机
    virsh net-define 根据xml文件创建虚拟网络
    virsh net-undefine 删除一个虚拟网络设备
    virsh net-edit 修改虚拟交换机的配置
    virsh net-autostart 设置开机自启动

    创建配置文件 /etc/libvirt/qemu/networks/vbr.xml

    [root@localhost ~]# vim /etc/libvirt/qemu/networks/vbr.xml
    <network>
      <name>vbr</name>
      <forward mode='nat'/>
      <bridge name='vbr' stp='on' delay='0'/>
      <ip address='192.168.100.254' netmask='255.255.255.0'>
        <dhcp>
          <range start='192.168.100.100' end='192.168.100.200'/>
        </dhcp>
      </ip>
    </network>
    

    创建虚拟交换机

    [root@localhost ~]# cd /etc/libvirt/qemu/networks/
    [root@localhost ~]# virsh net-define vbr.xml
    [root@localhost ~]# virsh net-start vbr
    [root@localhost ~]# virsh net-autostart vbr
    [root@localhost ~]# ifconfig # 查看验证
    
    虚拟机管理命令
    命令 说明
    virsh list [–all] 列出虚拟机
    virsh start/shutdown 启动/关闭虚拟机
    virsh destroy 强制停止虚拟机
    virsh define/undefine 创建/删除虚拟机
    virsh ttyconsole 显示终端设备
    virsh console 连接虚拟机的 console
    virsh edit 修改虚拟机的配置
    virsh autostart 设置虚拟机自启动
    virsh domfsinfo 查看文件系统信息
    virsh dominfo 查看虚拟机摘要信息
    virsh domiflist 查看虚拟机网卡信息
    virsh domblklist 查看虚拟机硬盘信息
    虚拟机配置文件

    官方文档地址 https://libvirt.org/format.html

    1、拷贝 node_base.xml 到虚拟机中

    2、拷贝 node_base.xml 到 /etc/libvirt/qemu/虚拟机名字.xml

    3、修改配置文件,启动运行虚拟机

    [root@localhost ~]# cp node_base.xml /etc/libvirt/qemu/vmhost.xml
    [root@localhost ~]# vim /etc/libvirt/qemu/vmhost.xml
    2:	<name>vmhost</name>
    3:	<memory unit='KB'>1024000</memory>
    4:	<currentMemory unit='KB'>1024000</currentMemory>
    5:	<vcpu placement='static'>2</vcpu>
    26:	<source file='/var/lib/libvirt/images/vmhost.img'/>
    
    创建虚拟机
    [root@localhost ~]# virsh list
    [root@localhost ~]# virsh define /etc/libvirt/qemu/vmhost.xml
    [root@localhost ~]# virsh start vmhost
    [root@localhost ~]# virsh console vmhost # 两次回车
    退出使用 ctrl + ]
    

    公有云简介

    常用终端管理工具

    xshell 使用技巧

    使用 lrzsz 上传下载文件

    安装软件

    [root@localhost ~]# yum install lrzsz
    

    配置 xshell 激活 zmodem

    退出重新登录以后,即可,上传(rz),下载(sz)

    展开全文
  • Docker技术( 容器虚拟化技术 )

    万次阅读 多人点赞 2019-10-18 19:59:21
    Docker虚拟化容器技术 第一章 Docker简介诞生背景Docker 介绍虚拟机技术容器虚拟化技术官方网址第二章 Docker安装前提条件安装DockerDocker底层原理Docker结构图工作原理Docker为什么比VM快第三章 Docker常用命令...

    第一章 Docker介绍

    诞生背景

    一款产品从开发到上线,从操作系统,到运行环境,再到应用配置。
    作为开发+运维之间的协作我们需要关心很多东西,这也是很多互联网公司都不得不面对的问题,
    特别是各种版本的迭代之后,不同版本环境的兼容,对运维人员都是考验 .
    Docker之所以发展如此迅速,也是因为它对此给出了一个标准化的解决方案。

    环境配置如此麻烦,换一台机器,就要重来一次,费力费时。
    很多人想到,能不能从根本上解决问题,软件可以带环境安装?
    也就是说,安装的时候,把原始环境一模一样地复制过来。
    开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。

    开发需要清楚的告诉运维部署团队,用的全部配置文件+所有软件环境。
    不过,即便如此,仍然常常发生部署失败的状况。
    Docker镜像的设计,使得Docker得以打破过去"程序即应用" 的观念。
    透过镜像(images)将作业系统核心除外,运作应用程式所需要的系统环境,
    由下而上打包,达到应用程式跨平台间的无缝接轨运作。

    在这里插入图片描述

    Docker 介绍

    Docker的主要目标是“Build,Ship and Run Any App,Anywhere”,
    也就是通过对应用组件的封装、分发、部署、运行等生命周期的管理,
    使用户的APP(可以是一个WEB应用或数据库应用等等)及其运行环境能够做到“一次封装,到处运行”。

    Linux 容器技术的出现就解决了这样一个问题,而 Docker 就是在它的基础上发展过来的。
    将应用运行在 Docker 容器上面,而 Docker 容器在任何操作系统上都是一致的,
    这就实现了跨平台、跨服务器只需要一次配置好环境,换到别的机子上就可以一键部署好, 大大简化了操作

    总结:
    Docker是解决运行环境和配置问题的软件容器 , 方便做持续集中并有助于整体发布的容器虚拟化技术

    在这里插入图片描述

    虚拟机技术与容器虚拟化技术

    虚拟机技术

    虚拟机(virtual machine)就是带环境安装的一种解决方案。
    可以在一种操作系统里面运行另一种操作系统,比如在Windows 系统里面运行Linux 系统。
    应用程序对此毫无感知,因为虚拟机看上去跟真实系统一模一样
    缺点 :1 资源占用多 2 冗余步骤多 3 启动慢

    在这里插入图片描述

    容器虚拟化技术

    Linux 容器(Linux Containers,缩写为 LXC)。
    Linux 容器不是模拟一个完整的操作系统,而是对进程进行隔离。
    有了容器,就可以将软件运行所需的所有资源打包到一个隔离的容器中。
    容器与虚拟机不同,不需要捆绑一整套操作系统,只需要软件工作所需的库资源和设置
    系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

    在这里插入图片描述
    二者区别

    1. 传统虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统,在该系统上再运行所需应用进程;
    2. 而容器内的应用进程直接运行于宿主机( 即:所在主机,下面统称宿主机 ) 的内核,容器内没有自己的内核,而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。
    3. 每个容器之间互相隔离,每个容器有自己的文件系统 ,容器之间进程不会相互影响,能区分计算资源。

    官方网址

    官方网址 : https://www.docker.com
    Docker社区官方:https://hub.docker.com/

    第二章 Docker安装

    Docker支持以下的CentOS版本:CentOS 7 (64-bit) ,CentOS 6.5 (64-bit) 或更高的版本

    前提条件

    目前,CentOS 仅发行版本中的内核支持 Docker。
    Docker 运行在 CentOS 7 上,要求系统为64位、系统内核版本为 3.10 以上。
    Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上,要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。

    # 查看内核版本
    uname -r 
    

    安装Docker

    Docker安装教程(CentOS 7)本人阿里云服务器装成功
    Docker安装教程(CentOS 7)本人腾讯云服务器装成功
    Docker安装教程(CentOS 6)

    Docker管理命令

    # 重新载入后台启动进程
    systemctl daemon-reload
    
    # 启动docker容器 ,每次关闭虚拟机/运服务器时需要启动( 重要!!! )
    sudo service docker start
    
    # 查看Docker容器状态
    sudo service docker status (should see active (running))
    
    # 运行hello-world镜像/测试Docker是否可以使用
    sudo docker run hello-world
    

    Docker底层原理

    Docker结构图

    在这里插入图片描述
    在这里插入图片描述

    工作原理

    Docker是一个Client-Server结构的系统,Docker守护进程运行在主机上,
    然后通过Socket连接从客户端访问,守护进程从客户端接受命令并管理运行在主机上的容器。
    容器,是一个运行时环境,就是我们前面说到的集装箱。

    在这里插入图片描述

    Docker为什么比VM快

    (1) docker有着比虚拟机更少的抽象层。
    由亍docker不需要Hypervisor实现硬件资源虚拟化,
    运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。
    因此在CPU、内存利用率上docker将会在效率上有明显优势。
    在这里插入图片描述

    (2) docker利用的是宿主机的内核,而不需要Guest OS。
    因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。
    因而避免引寻、加载操作系统内核返个比较费时费资源的过程,
    当新建一个虚拟机时,虚拟机软件需要加载Guest OS,返个新建过程是分钟级别的。
    而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟。
    通过下图着重了解二者的比较( 图很重要!!!)
    在这里插入图片描述

    第三章 Docker常用命令

    帮助命令

    # 查看docker版本信息
    docker version
    
    # 查看docker所有安装信息
    docker info
    
    # 查看docker帮助 ( 最为重要,学会利用帮助文档来学习 ,这是成为高手的必经之路!!! )
    docker --help
    

    镜像命令

    # 1.列出本地镜像(图1)
    docker images
    
    # option说明
     -a :列出所有镜像
     -q:只列出镜像id
     -digests :显示镜像的摘要信息
    --no-trunc :显示相信信息
    
    
    # 2.搜索某个镜像名字 (会在docker社区搜索相关的镜像, 而我们配置的阿里源只是帮我们同步了docker社区的镜像,图2)
    docker search 
    
    # option说明
    	- s显示收藏数不小于指定值的镜像
        --no-trunc :显示相信信息
        - automated :只列出automated类型的镜像
    
    # 3. 下载镜像(图3)
    docker pull 镜像的名字:[TAG](不写默认为 lasted)
    
    # 4. 删除镜像
    docker rmi  -f 镜像名/镜像id
    docker rmi -f $(docker images -qa )
       
    

    各个选项说明:
    REPOSITORY:表示镜像的仓库源
    TAG:镜像的标签
    IMAGE ID:镜像ID
    CREATED:镜像创建时间
    SIZE:镜像大小
    同一仓库源可以有多个 TAG,代表这个仓库源的不同个版本,我们使用 REPOSITORY:TAG 来定义不同的镜像。
    如果你不指定一个镜像的版本标签,例如你只使用 ubuntu,docker 将默认使用 ubuntu:latest 镜像

    图1
    在这里插入图片描述
    图2
    在这里插入图片描述

    图3
    在这里插入图片描述

    容器命令

    基本命令

    # 1. 新建并启动容器
    docker run [OPTIONS] IMAGE [COMMOND] [ARGS...]
    
    # OPTIONS 说明
    	--name="容器新名字": 为容器指定一个名称;
    	-d: 后台运行容器,并返回容器ID,也即启动守护式容器;
    	-i:以交互模式运行容器,通常与 -t 同时使用;
    	-t:为容器重新分配一个伪输入终端,通常与 -i 同时使用;
    	-P: 随机端口映射;
    	-p: 指定端口映射,有以下四种格式
    	      ip:hostPort:containerPort
    	      ip::containerPort
    	      hostPort:containerPort
    	      containerPort
    	      
    # eg: 使用镜像centos:latest以交互模式启动一个容器,在容器内执行/bin/bash命令。
    docker run -it centos /bin/bash 
    
     
    # 2. 查询当前正在运行的容器(类比虚拟中的查看进程)
    docker ps [OPTIONS] 
    
    # OPTIONS说明(常用):
    	-a :列出当前所有正在运行的容器+历史上运行过的
    	-l :显示最近创建的容器。
    	-n:显示最近n个创建的容器。
    	-q :静默模式,只显示容器编号。
    	--no-trunc :不截断输出。
    
    
    # 3. 退出容器
    exit  容器停止后退出
    ctrl+p+q  容器不停止退出
    
    # 4 .启动容器
    docker start 容器ID/容器名
    
    # 5. 重启容器 
    docker restart
    
    # 6. 停止容器
    docker stop 容器ID/容器名
    
    # 7. 强制停止容器
    docker kill 容器ID/容器名
    
    # 8. 删除已经停止的容器(如果没有停止,删除后悔停止)
    docker rm 容器ID
    删除多个容器(特别是第二种 ,先查询所有运行的进程, 然后通过管道传到后面的删除操作中)
    docker rm -f $(docker ps -a -q)
    docker ps -a -q | xargs docker rm
    

    重要命令

    # 1. 启动守护式容器(后台运行)
    docker -d 容器名
    
    # 使用镜像centos:latest以后台模式启动一个容器
    docker run -d centos
    
    问题:然后docker ps -a 进行查看, 会发现容器已经退出
    很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程.
    容器运行的命令如果不是那些一直挂起的命令(比如运行top,tail),就是会自动退出的。
    
    这个是docker的机制问题,比如你的web容器,我们以nginx为例,正常情况下,我们配置启动服务只需要启动响应的service即可。例如service nginx start
    但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,
    这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.
    所以,最佳的解决方案是,将你要运行的程序以前台进程的形式运行
    
    # 2. 查看容器日志
    docker logs -f -t --tail 容器ID
    
    eg :(图1)
    docker run -d centos /bin/sh -c "while true;do echo hello testLogs;sleep 2;done"
    docker logs -tf --tail 10 02c81778b0e0
    
    -t 是加入时间戳
    -f 跟随最新的日志打印
    --tail 数字 显示最后多少条
    
    
    # 3. 查看容器内运行的进程(图2)
    docker top 容器ID
    
    # 4. 查看容器内部细节(图3)
    docker inspect 容器ID
    
    # 5.进入正在运行的容器并进行交互(图4)
    docker exec -it 容器ID bashShell
    
    # 6. 重新进入容器(图5)
    docker attach 容器ID bashShell(不写的话默认 /bin/bash下)
    
    # 比较5与6的区别
    attach 直接进入容器启动命令终端, 不会启动新的线程
    exec 是在容器中打开新的终端, 并且可以启动新的线程
    

    图1
    在这里插入图片描述

    图2
    在这里插入图片描述
    图3
    在这里插入图片描述
    图4
    在这里插入图片描述
    图5
    在这里插入图片描述

    Docker常用命令图解

    在这里插入图片描述

    第四章 Docker镜像

    镜像 / UnionFS(联合文件系统)

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

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

    在这里插入图片描述
    总结:
    镜像就像洋葱圈 ,就像莲花卷 ,一层套一层 ,对外只显示一个文件系统.
    而且, 这种分层镜像还可以复用

    特点

    Dcoker镜像都是只读的 , 当启动容器时, 一个新的可写层被加载到镜像的顶部
    这一层被称为"容器层", "容器层"执行的都称为"镜像层"

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

    平时我们安装进虚拟机的CentOS都是好几个G,为什么docker这里才220M

    在这里插入图片描述
    对于一个精简的OS,rootfs可以很小,只需要包括最基本的命令、工具和程序库就可以了,
    因为底层直接用Host的kernel,自己只需要提供 rootfs 就行了。
    由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

    Docker镜像Commit操作

    # 提交容器副本实质成为一个新的镜像
    docker commit -m="提交的描述信息" -a="作者"	容器ID 要创建的目标镜像名:[标签名]
    
    
    eg: 同时docker运行tomcat案例
    # 1.  创建交互式界面 ( 相当于前台启动)
    docker run -it -p 8888:8080 tomcat   # 端口映射将8888作为docker的入口,映射到tomcat镜像的8080(图1,图2)
    docker run -it -P  tomcat  #自动端口映射(通过 docker ps查看端口, 图3)
    #后台启动(不会占用当前页面)
    docker run -d -p 8888:8080 tomcat 
    
    
    # 2. 进入tomcat (如果前置启动,另开一个窗口 ,后置启动则直接进入)
    # 查看运行容器ID
    docker ps  
    # 进入根目录
    docker exec -it 容器ID /bin/bash
    /usr/local/tomcat# rm -rf webapps/docs/ 
    # 删除后访问tomcat ,可以看到访问主页下的文档出现404(图4)
    
    # 3. 提交容器副本实使之为一个新的镜像
    # 查看运行容器ID
    docker ps  
    # 提交容器
    docker commit -m="del tomcat docs" -a="timepaus" 容器ID tomcat:v1.2
    # 查看镜像(图5)
    docker images
    
    # 4.同时启动新镜像并和原来的对比
    可以看到我们自己提交的新镜像也没有文档()
    但是我们重新下载的tomcat是有的
    

    图1
    在这里插入图片描述
    图2
    在这里插入图片描述
    图3
    在这里插入图片描述
    图4

    在这里插入图片描述
    图5
    在这里插入图片描述

    第五章 Docker容器数据卷

    简介

    类似Redis中的rdb文件和aof文件
    用于容器的持久化和荣期间的继承与共享数据

    容器内添加数据卷

    1.直接命令添加

    # 通过-v命令直接添加 (需要在根目录下创建 containerData  )
    # 创建后修改容器内containerData 会同步到hostData ,反之亦是如此
    docker run -it -v /hostData:/containerData  镜像名/ID
    
    # 创建只读权限的文件 , 容器内只能读取这个文件, 但是不能修改. ro: readonly
    docker run -it -v /宿主机绝路路径目录:/容器内目录:ro 镜像名
    

    2.Docker添加

    DockerFile的简单理解
    在这里插入图片描述

    # 1. 宿主机根目录下创建mydocker文件夹并进入
    
    
    # 2. 在mydocker文件想创建DockerFile文件并编辑,内容如下(图1)
    
    # volume test
    FROM centos
    VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
    CMD echo "finished,--------success1"
    CMD /bin/bash
    
    说明:
    出于可移植和分享的考虑,用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
    由于宿主机目录是依赖于特定宿主机的,并不能够保证在所有的宿主机上都存在这样的特定目录。
    
    
    3. 使用docker build命令创建一个镜像, 并挂载指定宿主机指定文件
    docker build -f /mydocker/DockerFile -t 定义的新镜像名称
    
    4. 查看镜像
    docker images
    
    5.运行新镜像
    docker run -it 定义的新镜像ID /bin/bash
    
    6.通过镜像运行后生成的容器ID查看 (图2), 对应的主机映射的数据卷地址
    docker ps
    docker inspect 容器ID
    
    7.测试添加卷和主机是否互通有无
    在容器中创建文件, 看看主机中是否创建对应的文件
    
    注意: 
    Docker挂载主机目录(第3步)Docker访问出现cannot open directory .: Permission denied
    解决办法:在挂载目录后多加一个--privileged=true参数即可
    

    图1
    在这里插入图片描述

    图2, 查看运行的容器id相关信息 docker inspect 容器ID
    在这里插入图片描述
    对比与总结
    在这里插入图片描述

    数据卷容器

    命名的容器挂载数据卷,其它容器通过挂载这个(父容器)实现数据共享,
    挂载数据卷的容器,称之为数据卷容器

    实现步骤

    # 1. 以上一步所建镜像为模板 ,首先启动一个父容器dc01 ,在创建容器的数据卷文夹中创建一个文件(图1)
    docker run -it --name 	dc01 zzyy/centos
    touch dc01_add.txt
    
    # 2. 创建子容器dc02,dc03继承自dc01 , 在创建容器的数据卷文夹中创建一个文件(图2)
    docker run -it --name dc02 --volumes-from dc01 zzyy/centos
    touch dc02_add.txt
    docker run -it --name dc03 --volumes-from dc01 zzyy/centos
    touch dc01=3_add.txt
    
    
    # 3. 回到dc01可以看到所有数据都被共享了(图3)
    # 4. 删除dc01, dc02修改后dc03是否可访问,可以 (图4)
    # 5. 删除dc02dc03是否可以访问, 可以(图5)
    # 6. 新建dc04继承dc03是否可以访问, 可以(图6)
    
    结论
    容器之间配置信息的传递, 数据卷的生命周期一直持续到没有容器使用它为止
    

    图1
    在这里插入图片描述
    图2
    在这里插入图片描述
    图3
    在这里插入图片描述
    图4
    在这里插入图片描述

    图5
    在这里插入图片描述
    图6
    在这里插入图片描述

    第六章 DockerFile解析

    介绍

    Dockerfile是用来构建Docker镜像文件 ,是有一系列命令和参数构成的脚本

    构建步骤

    1.编写Dockerfile文件
    2.docker build
    3.docker run

    格式

    以centos的文件为例

    FROM scratch
    ADD centos-8-container.tar.xz /
    
    LABEL org.label-schema.schema-version="1.0" \
        org.label-schema.name="CentOS Base Image" \
        org.label-schema.vendor="CentOS" \
        org.label-schema.license="GPLv2" \
        org.label-schema.build-date="20190927"
    
    CMD ["/bin/bash"]
    

    语法

    1. 每条保留字指令都必须为答谢字母且后面至少跟一个参数
    2. 指令从上到下, 顺序执行
    3. #表示注释
    4. 每条指令都会创建一个一个新的镜像层, 并提交

    Docker执行DockerFile的大致流程

    1. docker从基础镜像运行一个容器
    2. 执行一条指令并对容器做出修改
    3. 执行类似docker commit 的操作提交一个新的镜像层
    4. docker 再基于刚提交的镜像运行一个新容器
    5. 执行dockerfile 中的下一条执行, 直至所有指令都完成

    从应用软件的角度来看,Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段,

    • Dockerfile是软件的原材料
    • Docker镜像是软件的交付品
    • Docker容器则可以认为是软件的运行态。

    Dockerfile面向开发,Docker镜像成为交付标准,
    Docker容器则涉及部署与运维,三者缺一不可,合力充当Docker体系的基石。

    在这里插入图片描述

    1 Dockerfile,需要定义一个Dockerfile,Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道,这时需要考虑如何设计namespace的权限控制)等等;
    2 Docker镜像,在用Dockerfile定义一个文件之后,docker build时会产生一个Docker镜像,当运行 Docker镜像时,会真正开始提供服务;
    3 Docker容器,容器是直接提供服务的

    DockerFile保留字指令

    查看tomcat的DockerFile文件 ,更好理解保留字
    在这里插入图片描述

    保留字整合案例

    自定义镜像

    我们安装的centos精简版是没有vim和ifconfig命令的支持的
    我们可以通过编写Dockerfile令其支持这些功能

    # 1.搜索centos镜像并下载
    docker search centos
    docker pull centos
    
    # 2.编写创建一个文件( /mydoker/dockerfile_centos ),编写Dockerfile ,内容如下
    --------------------------------------------------------------------
    FROM centos
    MAINTAINER timepause<qq_43371556@csdn.net>
    
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    
    RUN yum -y install vim
    RUN yum -y install net-tools
    
    EXPOSE 80
    
    CMD echo $MYPATH
    CMD echo "install vim and ifconfig commond plug-in components success"
    CMD /bin/bash
    -----------------------------------------------------------------------
    
    
    
    # 3. 编译运行centos( 注意最后的空格和点号,图1 )
    docker build -f /mydoker/dockerfile_centos -t mycentos:1.3 .
    
    # 4. 测试功能( 图2 )
    # 查看是否新增镜像
    docker ps
    # 运行新镜像 
    docker run -it mycentos:1.3
    # 在容器中使用vim 与if config命令
    
    

    图1
    在这里插入图片描述

    图2
    在这里插入图片描述

    自定义tomcat9

    # 1. 创建存放生成镜像文件的目录
    mkdir -p /myuse/mydocker/tomcat9
    
    # 2.创建相关文件(c.txt用于测试)
    touch c.txt 
    
    
    # 3.上传tomcat和jdk(一定要注意版本, 根据版本修改Dockerfile文件, 图1)
    
    #. 4.创建并编辑Dockerfile(需要提前下载centos)
    vim Dockerfile
    ---------------------Dockerfile-------------------------------
    FROM         centos
    MAINTAINER    chy<chy@qq.com>
    #把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
    COPY c.txt /usr/local/cincontainer.txt
    #把java与tomcat添加到容器中
    ADD jdk-8u11-linux-x64.tar.gz /usr/local/
    ADD apache-tomcat-9.0.27.tar.gz /usr/local/
    #安装vim编辑器
    RUN yum -y install vim
    #设置工作访问时候的WORKDIR路径,登录落脚点
    ENV MYPATH /usr/local
    WORKDIR $MYPATH
    #配置java与tomcat环境变量
    ENV JAVA_HOME /usr/local/jdk1.8.0_11
    ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
    ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.27
    ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.27
    ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
    #容器运行时监听的端口
    EXPOSE  8080
    #启动时运行tomcat
    # ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh" ]
    # CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
    CMD /usr/local/apache-tomcat-9.0.27/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.27/bin/logs/catalina.out
    ---------------------Dockerfile-------------------------------
    
    
    
    
    # 5.构建镜像(在存放这些文件的目录下,图2)
    # 如果Dockerfile文件名称就是Dockerfile,可以省略参数 -f /Dockerfile所在位置的书写
    docker build -t mytomcat9 .
    
    # 6.查看镜像并运行镜像( 图3)
    docker images
    # 运行镜像 (后台启动, 成功后如图4)
    docker run -d -p 8080:8080 --name myt9 -v /myuse/mydocker/tomcat9/test:/usr/local/apache-tomcat-9.0.27/webapps/test -v /myuse/mydocker/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.27/logs --privileged=true  mytomcat9
    
    # 注意这里配置了容器卷的映射,宿主机的test文件夹映射到tomcat的webapps目录下的test文件,且二者可以互通有无. 
    docker exec -it 容器ID /bin/bash #进入容器根目录 ,可以访问相关页面
    
    # 7. 访问成功后, 添加jsp文件与web.xml文件( a.jsp用于访问测试 ,web.xml用于令jsp页面可以编译)
    vim a.jsp
    mkidr WEB-INF
    vim /WEB-INF/web.xml
    ------------------------------------------a.jsp---------------------------
    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
      <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Insert title here</title>
      </head>
      <body>
    
        -----------welcome------------
        <="i am in docker tomcat self "%>
        <br>
        <br>
        <% System.out.println("=============docker tomcat self");%>
      </body>
    </html>
    ------------------------------------------a.jsp---------------------------
    
    
    
    ------------------------------------------web.xml-----------------------------------
    <?xml version="1.0" encoding="UTF-8"?>
    
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                          http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
      version="4.0"
      metadata-complete="true">
    </web-app>
    ------------------------------------------web.xml-----------------------------------
    
    # 8. 重启服务, 访问a.jsp(图5)
    # 查看当前容器id
    docker ps (查看当前容器ID)
    docker ps -a (查看所有运行过的容器ID)
    # 重启服务
    docker restart 容器ID
    # 访问a.jsp页面
    

    图1
    在这里插入图片描述
    图2
    在这里插入图片描述

    图3
    在这里插入图片描述
    图4

    在这里插入图片描述
    图5

    在这里插入图片描述

    第七章 通过Docker安装软件

    MySQL

    # 1. 以安装mysql5.6为例(不知道什么原因5.7下不来)
    docker pull mysql:5.6
    
    # 2. 运行镜像,启动容器(端口3306,root用户密码:root,运行镜像:mysql5.6)
    docker run -p 3306:3306 --name mysql -v /datebase/mysql/conf:/etc/mysql/conf.d -v /datebase/mysql/logs:/logs -v /datebase/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.6
    
    # 3. 进入msql内部测试登陆
    docker ps
    ## 进入mysql的当前目录下
    docker exec -it MySQL运行成功后的容器ID/name     /bin/bash
    ## 输入账号密码
    mysql -u 账号 -p(然后根据提示输入密码)
    
    # 4.连接数据库的图形化界面
    
    # 5. 备份数据库数据,之后我们可以通过直接读取这个sql文件恢复数据
    docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"root" ' > /datebase/all-databases.sql
    

    在这里插入图片描述

    Redis

    # 1.下载最新版redis镜像
    docker pull redis
    
    # 2.运行镜像(redis端口2333, -d后的redis不加参数默认为redis:latest)
    # 注意本地数据卷与容器内数据卷目录的对应
    docker run -p 2333:6379 -v /myuse/myredis/data:/data -v /myuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis redis-server /usr/local/etc/redis/redis.conf --appendonly yes
    
    # 3.上传redis.conf到本地数据卷所在目录
    本地数据卷坐在目录 : /myuse/myredis/conf
    文件地址(太大了 ,这里放不下) : https://download.csdn.net/download/qq_43371556/11889084
    
    # 4. 运行redis的cil----shell命令行
    docker exec -it 运行着Rediis服务的容器ID redis-cli
    # 远程连接 docker redis
    docker exec -it redis_s redis-cli -h 192.168.1.100 -p 6379 -a your_password //如果有密码 使用 -a参数
    
    

    RabbitMQ

    # 1.下载镜像
    docker pull rabbitmq:3.7.7-management
    
    # 2.运行镜像
    docker run -d --name rabbitmq3.7.7 -p 5672:5672 -p 15672:15672 -v `pwd`/data:/var/lib/rabbitmq --hostname myRabbit -e RABBITMQ_DEFAULT_VHOST=/ -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin df80af9ca0c9
    
    -d 后台运行容器;
    --name 指定容器名;
    -p 指定服务运行的端口(5672:应用访问端口;15672:控制台Web端口号);
    -v 映射目录或文件;
    --hostname  主机名(RabbitMQ的一个重要注意事项是它根据所谓的 “节点名称” 存储数据,默认为主机名);
    -e 指定环境变量;(RABBITMQ_DEFAULT_VHOST:默认虚拟机名;RABBITMQ_DEFAULT_USER:默认的用户名;RABBITMQ_DEFAULT_PASS:默认用户名的密码)
    
    
    # 3.访问 (如下图)
    http://ip:15672
    账号 :admin
    密码: admin
    

    在这里插入图片描述

    MongoDB

    # 1.查看docker+MongoDB版本(图1)
    docker search
    
    # 2.下载最新的MongoDB
    docker pull MongoDB
    
    # 3.将镜像运行成容器
    docker run -itd --name mongo -p 27017:27017 mongo --auth
    ## 参数说明:
    -p 27017:27017 :映射容器服务的 27017 端口到宿主机的 27017 端口。外部可以直接通过 宿主机 ip:27017 访问到 mongo 的服务。
    --auth:需要密码才能访问容器服务。
    
    # 4.使用以下命令添加用户和设置密码,并且尝试连接。
    $ docker exec -it mongo mongo admin
    # 创建一个名为 admin,密码为 123456 的用户。
    >  db.createUser({ user:'admin',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'}]});
    # 尝试使用上面创建的用户信息进行连接。
    > db.auth('admin', '123456')
    

    图1
    在这里插入图片描述

    图2

    第八章 发布镜像到阿里云

    步骤

    # 1.登陆阿里云, 进入容器镜像服务(可以通过下方地址注册登录跳转到容器镜像服务)
    https://cr.console.aliyun.com/cn-hangzhou/instances/repositories
    
    # 2. 创建镜像仓库(图1)
    # 3. 在docker中登陆 ,根据图2,图3中的操作指南进行操作
    
    # 5. 将正在运行的容器创建成一个镜像(图4)
    docker commit 
    
    OPTIONS说明:
    -a :提交的镜像作者;
    -m :提交时的说明文字;
    
    # 4.将镜像推送到阿里云的镜像仓库(最好是根据阿里云上的操作指南)
    docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]
    sudo docker push registry.cn-hangzhou.aliyuncs.com/timepause/mydocker:[镜像版本号]
    
    # 5. 搜索镜像 ,下载镜像(图5,图6)
    docker pull 复制的镜像地址
    

    图1
    在这里插入图片描述
    图2
    在这里插入图片描述
    图3

    在这里插入图片描述

    图4
    在这里插入图片描述
    图5
    在这里插入图片描述
    图6
    在这里插入图片描述

    点击本博客相关学习视频地址

    展开全文
  • 虚拟化技术详解

    万次阅读 多人点赞 2018-07-14 17:10:52
    看到这篇文章的朋友,大部分应该都用过虚拟化软件,然后才会想知道虚拟化技术的。windows下的常用的虚拟化技术有VmWare,VirtualBox等等,那么这篇文章将会介绍这些技术基本的实现原理,并普及虚拟化相关的术语描述。 ...

    看到这篇文章的朋友,大部分应该都用过虚拟化软件,然后才会想知道虚拟化技术的。windows下的常用的虚拟化技术有VmWare,VirtualBox等等,那么这篇文章将会介绍这些技术基本的实现原理,并普及虚拟化相关的术语描述。

    目录

    虚拟化技术简介

    首先,什么是计算机?现在使用的计算机都离不开冯诺依曼体系结构,如图1所示,有输入设备、输出设备、存储器、cpu这就算是完整的计算机硬件环境了(当然还需要网卡、显卡等等)。虚拟化技术就是在一台机器上模拟出独立的cpu、存储器等使得同一台主机能虚拟为多台主机或者多台主机能虚拟为一台主机。本文只讨论第一种,让一台主机能够虚拟多台主机的环境。
    这里写图片描述
    图1 冯诺依曼体系结构

    现实生活中有各种各样的虚拟化技术,不同的虚拟化技术面对的应用场景也不一样。你可能用过VmVare或者VirtualBox来完成大学里面linux或者操作系统的学习,目的是为了在电脑上装上不同的操作系统。也有可能你是一名运维人员,你用过阿里云或者腾讯云,那么你作为租户,使用的其实是阿里云提供给你的一台虚拟机,阿里从大量的服务器集群中,分出了一定的cpu、内存等等资源给你,就成了一台完整的虚拟机。
    虚拟化使用软件的方法重新定义划分IT资源,可以实现IT资源的动态分配、灵活调度、跨域共享,提高IT资源利用率,使IT资源能够真正成为社会基础设施,服务于各行各业中灵活多变的应用需求。

    虚拟化分类

    在刘鹏的《云计算》书中,把虚拟化分为了两类,一类是建立在宿主机上的,也就是宿主机是有操作系统的,另一类是宿主机没有操作系统的,我们把前者称为寄居虚拟化,后者称为裸机虚拟化。

    寄居虚拟化

    寄居虚拟化如图2所示,最底层是物理硬件,物理硬件之上是主机的操作系统,操作系统之上是VMM(virtual machine monitor,虚拟机管理层),再往上就是客户的虚拟户了。
    这里写图片描述
    图2 寄居虚拟化

    在这种技术里面,虚拟机对各种物理设备(cpu、内存、硬盘等)的调用,都是通过VMM层和宿主机的操作系统一起协调才完成的。VMvare和VirtualBox都是基于这种方式实现的。

    裸机虚拟化

    裸机虚拟化指的是,直接将VMM安装在硬件设备与物理硬件之间,如图3所示。VMM在这种模式下又叫做Hypervisor,虚拟机有指令要执行时,Hypervisor会接管该指令,模拟相应的操作。
    这里写图片描述
    图3 裸机虚拟化

    Hypervisor是一种在虚拟环境中的“元”操作系统。他们可以访问服务器上包括磁盘和内存在内的所有物理设备。Hypervisor不但协调着这些硬件资源的访问,也同时在各个虚拟机之间施加防护。当服务器启动并执行Hypervisor时,它会加载所有虚拟机客户端的操作系统同时会分配给每一台虚拟机适量的内存,CPU,网络和磁盘。

    如果要进行虚拟化,必须要给虚拟机一个假的独立的环境,让他误以为自己处在一个独立的环境当中,于是就需要模拟cpu、内存、硬盘、网络等资源,模拟一个独立完整的硬件环境。

    cpu虚拟化

    cpu虚拟化指的就是把物理的cpu虚拟为多个虚拟cpu,从而实现一个cpu能被多台虚拟机共用,但是却相互隔离的场景。cpu的运转是以时间为单位的,cpu虚拟化要解决的问题主要是隔离和调度问题,隔离指的是让不同的虚拟机之间能够相互独立的执行命令,调度指的是VMM决定cpu当前在哪台虚拟机上执行。
    由于x86体系设计的cpu在虚拟化上具有一定的缺陷,所以我们有两种方法来实现cpu的虚拟化。其一是采用完全虚拟化的方式,利用动态指令转换或者硬件辅助来帮助实现cpu的虚拟化;其二是采用半虚拟化得方式,在客户的操作系统内核上进行一定的更改使得操作系统自己明白自己是虚拟机的角色,能够在VMM的管理下尽可能的访问硬件。
    如果某些同学对于cpu虚拟化想要有更加深入的了解,可以看一下这些博客:

    内存虚拟化

    内存提出的原因

    首先,内存存在的原因是cpu运转速度极快,超过了磁盘的读取速度,如果cpu直接读取硬盘的话,大部分的时间cpu都在等待。同时,程序访问又拥有局部性原理(80%的访问都在访问数据中20%的数据),于是乎就有牛人想到能不能用一小块儿读取速率快的存储设备来存放经常被读取的数据,这样cpu处理数据的速度就能和存储器读取设备的速度相匹配。系统性能达到最大化。

    虚拟内存

    虚拟内存是计算机OS经常要讲到的一块儿内容,为什么需要虚拟内存呢?,建议花几分钟时间读下面这篇博客,来帮助你理解我要说的内容。
    内存的发展
    通过上面这篇文章,你应该已经了解到一个内容,假设我们设定的虚拟内存是4G,虚拟内存就是给系统当中的每一个进程分配4G的虚拟地址,这样每个进程都感觉自己是独立的使用一块儿内存,具有良好的隔离性,同时,每个进程都是从0的虚拟地址开始的,这样就更有助于管理进程。但程序要运行,必须要运行在真实的内存上,所以会建立一种映射机制来帮助实现虚拟地址到物理地址之间的映射。
    通过虚拟内存的方式实现了进程之间的地址隔离。

    内存的虚拟化

    内存的虚拟化指的是把物理内存包装成若干虚拟内存来使用,把物理内存抽象出来,给每一台虚拟机都分配一个连续的内存空间。其具体的实现,可以参照下面的博文。
    内存虚拟化的实现

    硬盘虚拟化

    硬盘虚拟化相对简单一些,拿VMvare来举例,在VMvare当中,会使用物理硬盘上的一个文件来当做虚拟机当中的一个硬盘,如图4所示,虚拟机通过调用相关进程(如VMvare进程)访问相关的宿主机的文件系统,再通过文件系统调用windows内核,再调用驱动,然后在磁盘上进行读写。
    这里写图片描述
    图4 虚拟硬盘读写流程

    网络虚拟化

    网络虚拟化是让一个物理网络能够支持多个逻辑网络,虚拟化保留了网络设计中原有的层次结构、数据通道和所能提供的服务,使得最终用户的体验和独享物理网络一样,同时网络虚拟化技术还可以高效的利用网络资源如空间、能源、设备容量等。
    网络虚拟化的目的,是要节省物理主机的网卡设备资源。从资源这个角度去理解,可能会比较好理解一点。
    详情请参见这篇文章:网络虚拟化

    展开全文
  • 虚拟化技术发展简史 作者:张子良 版权所有,转载请注明出处  一 概述  虚拟化技术按照其发展历史,可以分为四个阶段:硬件仿真虚拟化、完全虚拟化、半虚拟化和操作系统虚拟化。当前阶段的虚拟化技术以半虚拟...

    虚拟化技术发展简史

    作者:张子良

    版权所有,转载请注明出处

      一 概述

      虚拟化技术按照其发展历史,可以分为四个阶段:硬件仿真虚拟化、完全虚拟化、半虚拟化和操作系统虚拟化。当前阶段的虚拟化技术以半虚拟化技术为主流,操作系统虚拟化是发展方向,目前主要应用在高端应用领域。下面将从每一种虚拟化技术的原理、优点、缺点和代表产品四个方面进行介绍。

      二 硬件仿真

      2.1 工作原理

      硬件虚拟化分为硬件指令虚拟化和硬件资源虚拟化,硬件指令虚拟化目的是将客户机发出的指令翻译成所在主机平台的指令,从而实现对客户机指令的模拟执行。硬件资源虚拟化目的是虚拟出硬件资源,通常主机平台与客户机平台所用的指令集是一样的,只是为了提高效率,将虚拟资源映射到物理资源,并在虚拟机计算中使用本地硬件。硬件虚拟化工作原理如下图所示:

     

      2.2 优点

      硬件仿真虚拟化由于采用了硬件仿真技术,硬件仿真的实现在宿主操作系统上实现,所以安装在仿真硬件上的操作系统,不需要做任何修改即可直接安装。例如我们可以在Windows上运行Symbian或Windows Mobile程序,只要有相应的硬件虚拟机即可。

      2.3 缺点

      硬件仿真虚拟化是最为复杂的虚拟化技术,需要在宿主操作系统上,创建一个硬件VM来仿真所想要的硬件。由于每条指令都必须在底层硬件上进行仿真,所以硬件仿真虚拟化技术的主要问题就是速度慢。

      2.4 代表产品

      

      三 完全虚拟化

      3.1 工作原理

       完全虚拟化(full virtualization)模型使用一个虚拟机,它在客户操作系统和原始硬件之间进行协调。"协调"在这里是一个关键,因为 VMM 在客户操作系统和裸硬件之间提供协调。特定受保护的指令必须被捕获下来并在 hypervisor 中进行处理,因为这些底层硬件并不由操作系统所拥有,而是由操作系统通过 hypervisor 共享。工作原理如下图所示:

      完全虚拟化分为传统完全虚拟化和硬件辅助的虚拟化。传统的完全虚拟化,虚拟机运行在操作系统之上,虚拟机管理程序本身运行在cpu的Ring 0,虚拟的Guest OS则运行在Ring 1(为了避免Guest OS破坏Host OS,Guest OS必须运行 在低于Ring 0的权限)。但是这样一来Guest的兼容性会受到影响,并且原来Guest OS要在Ring 0上执行的指令都必须经过hypervisor翻译才能运行,速度会有所下降。硬件辅助的完全虚拟化需要CPU硬件支持,有INTEL的VT和AMD的 AMD-V两种技术,只有支持这两种技术的CPU才可以使用。硬件辅助的虚拟化把虚拟机管理程序本身放到比Ring 0还低的模式运行(比如Ring -1),而把Guest OS放到Ring 0,这样兼容性得到了提高,不过因为第一代硬件虚拟技术(VT和AMD-V)实现上还不够成熟,所以效率上并不比传统的完全虚拟化更高。

      3.2 优点

       完全虚拟化的速度要比硬件仿真的速度要快,但是其性能低于裸硬件,因为中间经过了 hypervisor 的协调过程。完全虚拟化的最大优点是操作系统无需任何修改就可以直接运行。此外完全虚拟化还可使实现同时支持多个操作系统。

      3.3 缺点

      操作系统必须要支持底层硬件(例如 PowerPC)。

      3.4 代表产品

      传统的完全虚拟化的产品主要有Vmware Workstation / Server, Virtual PC / Server,Parallel Workstation等。硬件辅助的虚拟化受到很多产品的支持,目前传统的完全虚拟化产品也都开始对硬件辅助的虚拟化进行支持,比如Vmware Workstation / Server和VirtualBox都开始支持VT和AMD-V,并且在它们上面想要运行64位的Guest OS还必须使用硬件辅助的虚拟化。

      四 半虚拟化

      4.1 工作原理

      半虚拟化(paravirtualization),可以提供极高的性能,与完全虚拟化有一些类似。这种方法使用了一个 hypervisor 来实现对底层硬件的共享访问,将与虚拟化有关的代码集成到了操作系统本身中。与硬件辅助的完全虚拟化有一点相似是hypervisor运行在Ring -1,而Guest OS运行在Ring 0上。半虚拟化工作原理如下图所示:

      4.2 优点

      半虚拟化比完全虚拟化效率更高,速度更快,提供了与未经虚拟化的系统相接近的性能。

      4.3 缺点

      虚拟化有一个缺点是必须修改客户操作系统,因为半虚拟化为了提高效率,必须要让Guest OS本身意识到自己运行在虚拟机上,所以在Guest OS的内核中需要有方法来与hypervisor进行协调,这个缺点很大的影响了半虚拟化技术的普及,因为Linux等系统可以修改,而其它不能修改的系统就不能用了。

      4.4 代表产品

      半虚拟化的代表产品是Xen【zen】,Vmware ESX Server,Microsoft Hyper-V R1。Xen通过给Linux内核打补丁,使Host OS本身也运行在虚拟机上(叫做Domain 0),其它的虚拟机叫做Domain U(Domain U需要为Xen进行修改)。Hyper-V和Xen比较相似,Hyper-V目前集成在Windows 2008中,没启用Hyper-V时,只是一个普通的Windows 2008,一旦启用了Hyper-V,那么Hyper-V一开始就运行,而Windows 2008则在之上成为第一个虚拟机(叫做Parent partition,与Xen的Domain 0相似),在Hyper-V上运行的其它虚拟机应该也需要修改,不过Windows 2008已经修改过了所以可以在Hyper-V上运行。Vmware ESC Server本身集成在一个以Linux为基础的系统上,其架构和Xen及Hyper-V也是比较相似的。

      五 操作系统虚拟化

      5.1 工作原理

      操作系统级的虚拟化在操作系统本身之上实现服务器的虚拟化,特点是一个单一的节点运行着唯一的操作系统实例。通过在这个系统上加装虚拟化平台,可以将系统划分成多个独立隔离的容器,每个容器是一个虚拟的操作系统,被称为虚拟环境,也成为虚拟专用服务器。操作系统级的虚拟化原理如下图所示:

      5.2 优点

      操作系统级虚拟化技术直接和物理设备进行交换,极大的提高了系统性能。

      5.3 缺点

      操作系统级的虚拟化要求对操作系统的内核进行一些修改,但是其优点是可以获得原始性能。

      5.4 代表产品

      操作系统级虚拟以WMware ESX/ESXI和微软公司的Hyper-v Server 2008 R2服务器操作系统的典型应用,也是目前虚拟化技术领域的领跑者。

     

      以上部分是曾经写过的一个专题的第一章,特此分享,如果喜欢请点一下推荐,发表一下评论,多谢!

      

      

      

     

     

     

    展开全文
  • 了解虚拟化技术基础、服务器虚拟化、存储虚拟化和网络虚拟化技术
  • 目录 文章目录目录前文列表...《虚拟化技术实现 — 虚拟化技术发展编年史》 《虚拟化技术实现 — QEMU-KVM》 《虚拟化技术实现 — KVM 的 CPU 虚拟化》 虚拟存储器 Linux 虚拟存储器 内存虚拟化 KVM 的内存虚拟化 ...
  • 虚拟化技术实现 — KVM 的 I/O 虚拟化

    千次阅读 2020-05-03 10:58:54
    目录 文章目录目录前文列表VirtIO为什么需要 VirtIO?VirtIO 的架构VirtIO 的网络...前文列表 《虚拟化技术实现 — 虚拟化技术发展编年史》 《虚拟化技术实现 — QEMU-KVM》 《虚拟化技术实现 — KVM 的 CPU 虚拟化...
  • 虚拟化技术简介

    2020-05-15 17:39:23
    虚拟化技术重要性2.虚拟化技术的分类2.1 硬件抽象层上的虚拟化2.2 操作系统层上的虚拟化2.3 库函数层上的虚拟化2.4 编程语言层上的虚拟化3.系统级虚拟化3.1 按照实现方法分类3.2 按照实现结构分类4.操作系统级虚拟化...
  • 深入剖析虚拟化技术概念和应用场景虚拟化,一是项技术~~,是一种资源解决方案。虚拟化技术是将物理资源转变为逻辑上可以管理的资源,以打破物理结构之间的壁垒,使计算元件运行在虚拟的基础上,而不是真实的物理...
  • 虚拟化技术:百度百科中的定义是这样的:虚拟化是一个广义的术语,在计算机方面通常是指计算元件在虚拟的基础上而不是真实的基础上运行。虚拟化技术可以扩大硬件的容量,简化软件的重新配置过程。CPU的虚拟化技术...

空空如也

1 2 3 4 5 ... 20
收藏数 24,137
精华内容 9,654
关键字:

虚拟化技术