精华内容
下载资源
问答
  • 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.连接数据库的图形化界面
    ## Mysql 解决连接客户端时出现1251 client does not support ...问题
    ALTER USER  'root'@'%' IDENTIFIED WITH mysql_native_password BY 'mysql密码';
    ALTER USER  'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'mysql密码';
    
    # 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 mongo
    
    # 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
    在这里插入图片描述

    安装vsftpd+Nignx(图片服务器)

    环境搭建

    通过搭建Nginx和vfstpd 实现文件服务器

    # 1. 安装docker-compose . 实现对相关软件的配置
    curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
    chmod +x /usr/local/bin/docker-compose
    
    # 2. 编写docker-compose.yml 配置文件
    ## 需要需要修改的地方的是: 
    ## /data/ftp:/home/vsftpd/ftpuser(20行), /data/ftp 是ftp中图片存放的地址
    ## /data/ftp:/home/images(11行) , /data/ftp 是Nginx来对应ftp中图片存放的地址
    ## FTP_USER,FTP_PASS 代表ftp用户的账号和密码, 需要在Linux中提前添加用户 
    ## 添加用户命令 a. useradd ftpuser,b. passwd ftpuser 然后输入自定义密码  
    ## ~/pic/nginx/conf/nginx.conf(9行), 注意! 需要提前准备Nginx的配置文件nginx.conf, ~ 代表home目录
    ## PASV_ADDRESS: 192.168.40.21, PASV_ADDRESS后面填写的是ftp服务器的ip
    ----------------docker-compose.yml---------------------
    version: '2'
    services:
      nginx-image:
        image: nginx:1.15.8
        ports:
          - "80:80"
        volumes:
          - ~/pic/nginx/html:/usr/share/nginx/html
          - ~/pic/nginx/conf/nginx.conf:/etc/nginx/nginx.conf
          - ~/pic/nginx/logs:/var/log/nginx
          - /data/ftp:/home/images
        restart: always
      vsftpd:
        image: fauria/vsftpd
        ports:
          - "20:20"
          - "21:21"
          - "21100-21110:21100-21110"
        volumes:
          - /data/ftp:/home/vsftpd/ftpuser
        environment:
          FTP_USER: ftpuser
          FTP_PASS: 1q2w3e4r
          PASV_ADDRESS: 192.168.40.21
          PASV_MIN_PORT: 21100
          PASV_MAX_PORT: 21110
          LOCAL_UMASK: 022
        restart: always
    -------------------------------------
    
    # 3. 分享上面需要nginx.conf文件放在下面了
    vim /home/pic/nginx/conf/nginx.conf
    
    # 4. docker-compose执行, 需要在docker-compose.yml所在的目录下执行
    docker-compose up -d
    
    # 5. docker ps(查看容器是否执行, 下图1)
    

    图1
    在这里插入图片描述

    上面第三步所需的nginx.conf配置文件

    # root   /data/ftp/, /data/ftp/代表的是我们上面配置的ftp图片存放的地址, 只需要修改这一处
    location / { root   /data/ftp/;i ..... }
    

    完整配置文件

    #user  nobody;
    worker_processes  1;
    
    #error_log  logs/error.log;
    #error_log  logs/error.log  notice;
    #error_log  logs/error.log  info;
    
    #pid        logs/nginx.pid;
    
    
    events {
        worker_connections  1024;
    }
    
    
    http {
        include       mime.types;
        default_type  application/octet-stream;
    
        #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
        #                  '$status $body_bytes_sent "$http_referer" '
        #                  '"$http_user_agent" "$http_x_forwarded_for"';
    
        #access_log  logs/access.log  main;
    
        sendfile        on;
        #tcp_nopush     on;
    
        #keepalive_timeout  0;
        keepalive_timeout  65;
    
        #gzip  on;
    
        server {
            listen       80;
            server_name  localhost;
    
            #charset koi8-r;
    
            #access_log  logs/host.access.log  main;
    
            location / {
                root   /data/ftp/; # /data/ftp/代表的是我们上面配置的ftp图片存放的地址, 只需要修改这一处
                index  index.html index.htm;
            }
    
            #error_page  404              /404.html;
    
            # redirect server error pages to the static page /50x.html
            #
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
        }
    
    
    
    }
    
    

    代码测试

    1. 添加依赖
    <!--文件上传与下载-->
             <dependency>
                 <groupId>commons-net</groupId>
                 <artifactId>commons-net</artifactId>
                 <version>3.3</version>
             </dependency>
             <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.7</version>
                <scope>compile</scope>
            </dependency>
    
    1. 工具类代码
    package com.clife.common.utils;
    
    import org.apache.commons.net.ftp.FTP;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.apache.commons.net.ftp.FTPReply;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Value;
    
    import java.io.*;
    
    /**
     * ftp上传下载工具类
     */
    public class FtpUtil {
    
    	private static   String hostname="192.168.40.21";
    	private static   int port=21;
    	private static   String ftpusername="ftpuser";
    	private static   String ftppassword="ftpuser";
    	private static   String basePath="/data/ftp";
    	private static   String filePath="";
    
    	//日志打印
    	private static Logger logger = LoggerFactory.getLogger(FtpUtil.class);
    
    	/**
    	 * 文件上传封装方法
    	 * @param sourceFileName 本地文件绝对地址,目录+文件名, eg:D:\\1.jpg
    	 * @param targetFileName 上传到ftp服务器/data/ftp/目录下的文件名
    	 * @return
    	 * @throws FileNotFoundException
    	 */
    	public static boolean ftpUploadFile(String sourceFileName, String targetFileName) throws FileNotFoundException {
    		FileInputStream in=new FileInputStream(new File(sourceFileName));
    		boolean b = uploadFile(hostname, port, ftpusername, ftppassword, basePath, filePath, targetFileName, in);
    		return b;
    	}
    
    	/**
    	 * Description: 向FTP服务器上传文件
    	 * @param host FTP服务器hostname
    	 * @param port FTP服务器端口
    	 * @param username FTP登录账号
    	 * @param password FTP登录密码
    	 * @param basePath FTP服务器基础目录
    	 * @param filePath FTP服务器文件存放路径。例如分日期存放:/2015/01/01。文件的路径为basePath+filePath
    	 * @param filename 上传到FTP服务器上的文件名
    	 * @param input 输入流
    	 * @return 成功返回true,否则返回false
    	 */
    public static boolean uploadFile(String host, int port, String username, String password, String basePath,
    			String filePath, String filename, InputStream input) {
    		boolean result = false;
    		FTPClient ftp = new FTPClient();
    		try {
    			int reply;
    			ftp.connect(host, port);// 连接FTP服务器
    			logger.info("连接ftp成功...");
    			// 如果采用默认端口,可以使用ftp.connect(host)的方式直接连接FTP服务器
    			ftp.login(username, password);// 登录
    			logger.info("ftp用户登陆成功!!!");
    			reply = ftp.getReplyCode();
    			if (!FTPReply.isPositiveCompletion(reply)) {
    				ftp.disconnect();
    				return result;
    			}
    			//切换到上传目录
    			if (!ftp.changeWorkingDirectory(basePath+filePath)) {
    				//如果目录不存在创建目录
    				String[] dirs = filePath.split("/");
    				String tempPath = basePath;
    				for (String dir : dirs) {
    					if (null == dir || "".equals(dir)) {continue;}
    					tempPath += "/" + dir;
    					if (!ftp.changeWorkingDirectory(tempPath)) {
    						if (!ftp.makeDirectory(tempPath)) {
    							return result;
    						} else {
    							ftp.enterRemotePassiveMode();
    							ftp.changeWorkingDirectory(tempPath);
    						}
    					}
    				}
    			}
    			//设置上传文件的类型为二进制类型
    			ftp.setFileType(FTP.BINARY_FILE_TYPE);
    			//上传文件
    			if (!ftp.storeFile(filename, input)) {
    				logger.info("文件 {} 上传失败!",filename);
    				return result;
    			}
    			input.close();
    			ftp.logout();
    			result = true;
    			logger.info("文件 {} 上传成功!",filename);
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			if (ftp.isConnected()) {
    				try {
    					ftp.disconnect();
    				} catch (IOException ioe) {
    				}
    			}
    		}
    		return result;
    	}
    
    
    
    	public static void main(String[] args) {
    		//FileInputStream in=new FileInputStream(new File("D:\\1.jpg"));
    		//boolean flag = uploadFile("192.168.40.21", 21, "ftpuser", "ftpuser", "/data/ftp","", "123.png", in);
    		boolean flag = false;
    		try {
    			flag = ftpUploadFile("D:\\11.jpg", "6666.jpg");
    			System.out.println(flag);
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		}
    
    
    	}
    }
    
    
    1. 图片访问
      http://192.168.40.21/6666.jpg

    第八章 发布镜像到阿里云

    步骤

    # 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
    在这里插入图片描述


    点击本博客相关学习视频地址
    图片服务器参考博客

    展开全文
  • Docker安全特性有哪些 Docker?平台还引入了大量自有安全技术Swarm 模式基于 TLS 构建并且配置上极其简单灵活安全扫描对镜像进行二进制源码级别扫描并提供已知缺陷的详细报告 Docker 内容信任允许用户对内容进行签名...
  • Docker特性解析

    2019-09-28 01:11:54
    Docker简介与入门:http://segmentfault.com/blog/p_chou/1190000000448808 ...不过本文探讨了Docker的特点、特性、原理,还介绍了具有中国特色的安装测试过程,另外还谈到了Docker的社区生态和...

    Docker简介与入门http://segmentfault.com/blog/p_chou/1190000000448808

            Docker是个新生的事物,概念类似虚拟化。网上关于Docker入门的东西已经很多了。不过本文探讨了Docker的特点、特性、原理,还介绍了具有中国特色的安装测试过程,另外还谈到了Docker的社区生态和Dockerfile,并使用Dockerfile构建一个nginx环境。

    原文:Docker简介与入门

    缘起

    在几个月前听说Docker,但是一直没有时间去研究,前一段时间趁着azure免费试用,赶紧实验一下,但是卡在了ubuntu基础镜像的下载上(由于国内网络的特殊原因),所以也就搁浅了。在逛Segmentfault的时候,看到上面有个Docker子站问答,逛了逛果然有干货,于是重新试了一下,这里把经验和体会分享一下。

    Docker简介

    我觉得简单来说,Docker就是一个应用程序执行容器,类似虚拟机的概念。但是与虚拟化技术的不同点在于下面几点:

    1. 虚拟化技术依赖物理CPU和内存,是硬件级别的;而docker构建在操作系统上,利用操作系统的containerization技术,所以docker甚至可以在虚拟机上运行。
    2. 虚拟化系统一般都是指操作系统镜像,比较复杂,称为“系统”;而docker开源而且轻量,称为“容器”,单个容器适合部署少量应用,比如部署一个redis、一个memcached。
    3. 传统的虚拟化技术使用快照来保存状态;而docker在保存状态上不仅更为轻便和低成本,而且引入了类似源代码管理机制,将容器的快照历史版本一一记录,切换成本很低。
    4. 传统的虚拟化技术在构建系统的时候较为复杂,需要大量的人力;而docker可以通过Dockfile来构建整个容器,重启和构建速度很快。更重要的是Dockfile可以手动编写,这样应用程序开发人员可以通过发布Dockfile来指导系统环境和依赖,这样对于持续交付十分有利。
    5. Dockerfile可以基于已经构建好的容器镜像,创建新容器。Dockerfile可以通过社区分享和下载,有利于该技术的推广。

    Docker的主要特性如下(摘自Docker:具备一致性的自动化软件部署):

    1. 文件系统隔离:每个进程容器运行在完全独立的根文件系统里。
    2. 资源隔离:可以使用cgroup为每个进程容器分配不同的系统资源,例如CPU和内存。
    3. 网络隔离:每个进程容器运行在自己的网络命名空间里,拥有自己的虚拟接口和IP地址。
    4. 写时复制:采用写时复制方式创建根文件系统,这让部署变得极其快捷,并且节省内存和硬盘空间。
    5. 日志记录:Docker将会收集和记录每个进程容器的标准流(stdout/stderr/stdin),用于实时检索或批量检索。
    6. 变更管理:容器文件系统的变更可以提交到新的映像中,并可重复使用以创建更多的容器。无需使用模板或手动配置。
    7. 交互式Shell:Docker可以分配一个虚拟终端并关联到任何容器的标准输入上,例如运行一个一次性交互shell。

    目前Docker正处在开发阶段,官方不建议用于生产环境。另外,Docker是基于Ubuntu开发的,所以官方推荐将其安装在Ubuntu的操作系统上,目前只能安装在linux系统上

    Docker的使用入门

    Docker官方的安装指导挺详细的。但是由于国内的特殊情况,我这里基于这个安装指导,给出适用于国内开发者的入门过程。基于Ubuntu Precise 12.04 (LTS) (64-bit),推荐这个版本,其他版本参考官方安装手册。

    Docker的安装

    首先,Docker官方声称最好是运行在Linux内核3.8以上,所以要先进行内核升级

    # install the backported kernel
    sudo apt-get update
    sudo apt-get install linux-image-generic-lts-raring linux-headers-generic-lts-raring
    
    # reboot
    sudo reboot
    

    添加Docker仓库的key:

    sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 36A1D7869245C8950F966E92D8576A8BA88D21E9
    

    添加镜像,这里直接用俄罗斯的Yandex

    sudo sh -c "echo deb http://mirror.yandex.ru/mirrors/docker/ docker main > /etc/apt/sources.list.d/docker.list"
    sudo apt-get update
    

    安装Docker

    sudo apt-get install lxc-docker
    

    一般上面的步骤不会有任何问题。

    Docker镜像下载

    Docker运行至少需要一个ubuntu的基础镜像,这个镜像会在你初次尝试执行时自动下载,不过从国内直接用基本上就别想了,需要使用代理。这里用Docker中文社区提供的代理。出处1,出处2

    修改/etc/default/docker文件,取消注释http_proxy的部分:

    # If you need Docker to use an HTTP proxy, it can also be specified here.
    export http_proxy=http://192.241.209.203:8384/  
    

    经过笔者测试,上面这个代理也不是很稳定,可能用的人比较多吧。

    可用的代理地址(持续关注中)

    http://192.241.209.203:8384

    然后,你就可以执行下面的命令,测试执行了,由于代理不是很稳定,可能需要多尝试几次(淡定):

    sudo docker run -i -t ubuntu /bin/bash
    

    下面这个截图是我成功pull完成,并测试hello world成功(大概尝试了3-4次):
    docker-introduction-1

    Docker的社区和生态

    仓库和镜像

    评估一项开源技术很大程度上需要关注它的社区和生态。Docker的生态是通过推送和拉取特定的“镜像(image)包”来展开的。你可以从docker index上搜索需要的镜像。也可以通过下面的命令搜索:

    sudo docker search
    

    镜像可以看作是包含有某些软件的容器系统,比如ubuntu就是一个官方的基础镜像,很多镜像都是基于这个镜像“衍生”,该镜像包含基本的ubuntu系统。再比如,hipache是一个官方的镜像容器,运行后可以支持http和websocket的代理服务,而这个镜像本身又基于ubuntu

    通过pull来拉取镜像,将镜像下载到本地,比如

    sudo docker pull hipache
    

    通过images查看现在有哪些镜像:

    sudo docker images
    
    REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
    ubuntu              13.10               9f676bd305a4        6 weeks ago         178 MB
    ubuntu              saucy               9f676bd305a4        6 weeks ago         178 MB
    ubuntu              13.04               eb601b8965b8        6 weeks ago         166.5 MB
    ubuntu              raring              eb601b8965b8        6 weeks ago         166.5 MB
    ubuntu              12.10               5ac751e8d623        6 weeks ago         161 MB
    ubuntu              quantal             5ac751e8d623        6 weeks ago         161 MB
    ubuntu              10.04               9cc9ea5ea540        6 weeks ago         180.8 MB
    ubuntu              lucid               9cc9ea5ea540        6 weeks ago         180.8 MB
    ubuntu              12.04               9cd978db300e        6 weeks ago         204.4 MB
    ubuntu              latest              9cd978db300e        6 weeks ago         204.4 MB
    ubuntu              precise             9cd978db300e        6 weeks ago         204.4 MB
    

    上面的都是镜像,都从属于ubuntu仓库(一般仓库名应该是username/repository格式,如果是直接以repository作为仓库名的,是指官方发布的仓库)。我们拉取ubuntu的时候,实际上是把仓库里的镜像都拉下来了。每个镜像都有一个唯一的IMAGE ID,和一个易于记忆的TAG,可以通过IMAGE ID的前几位或者repository:TAG来标识一个镜像。

    Dockerfile和通过Dockerfile来构建Nginx容器

    除了pull,镜像也可以通过"编译"得到,这里的"编译"是指一种构建行为,通过手动编写或者从github获取Dockerfile来构建一个镜像。可以把Dockerfile看成是一个脚本,这个脚本会在容器每次启动时执行。一般在Dockerfile里面需要编写基础软件的安装脚本和配置脚本。下面这个Dockerfile是个例子:

    #
    # Ubuntu Dockerfile
    #
    # https://github.com/dockerfile/ubuntu
    #
    
    # Pull base image.
    FROM ubuntu:12.10
    
    # Update OS.
    RUN echo "deb http://archive.ubuntu.com/ubuntu quantal main universe multiverse" > /etc/apt/sources.list
    RUN apt-get update
    RUN apt-get upgrade -y
    
    # Install basic packages.
    RUN apt-get install -y software-properties-common
    RUN apt-get install -y curl git htop unzip vim wget
    
    # Add files.
    ADD root/.bashrc /root/.bashrc
    ADD root/.gitconfig /root/.gitconfig
    ADD root/scripts /root/scripts
    
    # Set working directory.
    ENV HOME /root
    WORKDIR /root
    

    FROM指令表示这次构建需要基于ubuntu仓库的12.10这个TAG的镜像,如果本地不存在这个镜像的话,会自动下载镜像。镜像实际上就是编译好的结果。向上面这个Dockerfile,在原始ubuntu的基础上安装了很多常用的软件。

    docker官方有Dockerfile的教程

    实践

    首先确保你已经完成上面的安装步骤,并拉取到基础镜像ubuntu:12.10。

    现在我们用上面的Dockerfile来构建这个仓库(上面的Dockerfile实际上是github dockerfile项目的基本仓库dockerfile/ubuntu,所下面的命令直接从github下载Dockerfile来构建)

    sudo docker build -t="dockerfile/ubuntu" github.com/dockerfile/ubuntu
    

    下面是最后构建成功时的输出:

    ...
    Processing triggers for ureadahead ...
     ---> 0a4392cf8e2d
    Step 6 : ADD root/.bashrc /root/.bashrc
     ---> b0e86f348c09
    Step 7 : ADD root/.gitconfig /root/.gitconfig
     ---> e2a9c001d457
    Step 8 : ADD root/scripts /root/scripts
     ---> 678febabdbdc
    Step 9 : ENV HOME /root
     ---> Running in c4afef311cf1
     ---> eaa3ae3277a8
    Step 10 : WORKDIR /root
     ---> Running in d50c273c75b8
     ---> c9ecf5bc3227
    Successfully built c9ecf5bc3227
    Removing intermediate container 1a3d1f794c49
    Removing intermediate container 9f72df8abb63
    Removing intermediate container 5694d1e3e77e
    Removing intermediate container 6a184821f89c
    Removing intermediate container 8195bd05fc36
    Removing intermediate container d50c273c75b8
    Removing intermediate container 70de07353ecf
    Removing intermediate container 73e3f6204613
    Removing intermediate container 5dd948415981
    Removing intermediate container c4afef311cf1
    

    此时会多出一个仓库:

    sudo docker images
    REPOSITORY          TAG                 IMAGE ID            CREATED              VIRTUAL SIZE
    dockerfile/ubuntu   latest              c9ecf5bc3227        About a minute ago   294.2 MB
    ...
    

    现在我们可以来构建dockerfile/nginx了(当然,从一开始你就可以直接pull这个镜像)

    sudo docker build -t="dockerfile/nginx" github.com/dockerfile/nginx
    

    完成后,会看到编译好的镜像:

    sudo docker images
    REPOSITORY          TAG                 IMAGE ID            CREATED              VIRTUAL SIZE
    dockerfile/nginx    latest              68508350c656        About a minute ago   308.3 MB
    dockerfile/ubuntu   latest              c9ecf5bc3227        16 minutes ago       294.2 MB
    ...
    

    现在是时候看到真正的效果了!用下面这个命令运行容器:

    sudo docker run -d -p 80:80 dockerfile/nginx
    

    这个命令会以daemon的方式运行容器,通过下面命令查看正在运行的容器:

    sudo docker ps
    CONTAINER ID        IMAGE                     COMMAND             CREATED             STATUS              PORTS                NAMES
    98c474a7dd6a        dockerfile/nginx:latest   nginx               6 seconds ago       Up 6 seconds        0.0.0.0:80->80/tcp   trusting_hawking
    

    访问你主机的80端口,可以看到nginx的欢迎页面了!这时,我们来看看本机的进程sudo ps -ef

    root      1428   952  0 15:19 ?        00:00:00 nginx: master process nginx
    root      1429   417  0 15:19 ?        00:00:00 /sbin/udevd --daemon
    www-data  1441  1428  0 15:19 ?        00:00:00 nginx: worker process
    www-data  1442  1428  0 15:19 ?        00:00:00 nginx: worker process
    www-data  1443  1428  0 15:19 ?        00:00:00 nginx: worker process
    www-data  1444  1428  0 15:19 ?        00:00:00 nginx: worker process
    

    似乎有些接近事物的本质了!nginx的进程实际上是在本机上的,这意味着,容器中程序的执行仍然是使用本机操作系统的,容器并不自己构建操作系统,而是以某种隔离的方式依赖本机操作系统工作。这就是Docker和虚拟机的本质区别。

    你可以像下面这样,将本机的目录映射给这个"nginx容器"。<sites-enabled-dir>目录下应该有nginx的配置文件片段

    docker run -d -p 80:80 -v <sites-enabled-dir>:/etc/nginx/sites-enabled -v <log-dir>:/var/log/nginx dockerfile/nginx
    

    PS:这步笔者没有成功,日志路径是可以map的,但是sites-enable-dir中的配置始终不行。继续诊断中。

    镜像的共享与Dockfile的分发

    可以共享你的镜像和用来构建的Dockfile分享给社区:

    原理

    总的来说Docker的核心技术如下:

    • 命名空间
    • AUFS(advanced multi layered unification filesystem)
    • cgroup

    由于本人才疏学浅,下面给出一些参考资料,有兴趣的朋友可以扩展阅读一下,一定会对Docker有更深刻的认识的:

    PaaS under the hood, episode 1: kernel namespaces

    PaaS Under the Hood, Episode 2: cgroups

    PAAS Under the Hood, Episode 3: AUFS

    PaaS Under the Hood, Episode 4: GRSEC

    PaaS under the hood, episode 5: Distributed routing with Hipache

    Under the Hood系列

    LXC (Linux 虚拟环境)简单介绍

    docker原理简介

    参考资料

    Docker官方

    Docker:具备一致性的自动化软件部署

    Dockerfile的教程

    一些Docker的社区资源:

    SegmentfaultDocker子站问答

    Docker中文社区

    Docker中文文档


    转载于:https://www.cnblogs.com/wishchin/p/9200211.html

    展开全文
  • kubernetes1.4新特性:支持Docker特性

    万次阅读 2016-10-08 10:04:59
    (一)背景资料 在Kubernetes1.2中这个第三方组件就是go-dockerclient,这是一个GO语言写的docker客户端,支持Docker...在Kubernetes1.3中直接使用docker公司提供的client来实现,通过这个client可以实现同DockerD

    (一)背景资料

    • 在Kubernetes1.2中这个第三方组件就是go-dockerclient,这是一个GO语言写的docker客户端,支持Dockerremote API,这个项目在https://github.com/fsouza/go-dockerclient中。
    • 在Kubernetes1.3中直接使用docker公司提供的client来实现,通过这个client可以实现同DockerDeamon之间的通讯,这个客户端项目在https://github.com/docker/engine-api/中,感兴趣的话可以去看看。
    • 在Kubernetes1.4中延用了1.3中的方式,直接使用docker公司提供的client来实现。

    (二)支持Docker版本

    • 对于Kubernetes1.4需要使用Docker版本至少是1.9.x,Docker1.9.x对应的API版本是1.21。
    • 下面是Docker版本同API版本对应关系,其中红色字体的部分是Kubernetes1.4不支持的。

    Docker版本

    API版本

    1.12x

    1.24

    1.11.x

    1.23

    1.10.x

    1.22

    1.9.x

    1.21

    1.8.x

    1.20

    1.7.x

    1.19

    1.6.x

    1.18

    1.5.x

    1.17

    1.4.x

    1.16

    1.3.x

    1.15

    1.2.x

    1.14

    (三)调用Docker API

    下面表格展现了Docker最新版本所有的API列表,同时也展现了Kubernetes1.4版本和1.3版本都使用了哪些API。

    • 第一列是Docker 1.24版本API列表
    • 第二列是这些API使用方式
    • 第三列是Kubernetes1.4中使用到的API
    • 第四列是Kubernetes1.3中使用到的API
    • 红色字体部分为1.4版本比1.3版本增加的调用API,也就是说1.4版本比1.3版本增加的操作Docker的功能

    Docker API 1.24

    使用方式

    Kubernetes1.4

    Kubernetes1.3

    Get container stats based on resource usage

    GET /containers/(id)/stats

     

     

    Update a container

    POST /containers/(id)/update

     

     

    Rename a container

    POST /containers/(id)/rename

     

     

    Retrieving information about files and folders in a container

    HEAD /containers/(id)/archive

     

     

    List containers

    GET /containers/json

    Inspect a container

    GET /containers/(id)/json

    Inspect changes on a container’s filesystem

    GET /containers/(id)/changes

    Create a container

    POST /containers/create

    Start a container

    POST /containers/(id)/start

    Stop a container

    POST /containers/(id)/stop

    Restart a container

    POST /containers/(id)/restart

     

     

    Pause a container

    POST /containers/(id)/pause

     

     

    Unpause a container

    POST /containers/(id)/unpause

     

     

    List processes running inside a container

    GET /containers/(id)/top

     

     

    Kill a container

    POST /containers/(id)/kill

    Remove a container

    DELETE /containers/(id)

    Get an archive of a filesystem resource in a container

    GET /containers/(id)/archive

     

     

    Extract an archive of files or folders to a directory in a container

    PUT /containers/(id)/archive

     

     

    Copy files or folders from a container

    POST /containers/(id)/copy,以后会被删除掉,使用archive代替

     

     

    Wait a container

    POST /containers/(id)/wait

     

     

    Create a new image from a container’s changes

    POST /commit

     

     

    Attach to a container

    POST /containers/(id)/attach

    Attach to a container (websocket)

    GET /containers/(id or name)/attach/ws

     

     

    Get container logs

    GET /containers/(id)/logs

    Resize a container TTY

    POST /containers/(id)/resize

     

    Export a container

    GET /containers/(id)/export

     

     

    List Images

    GET /images/json

    Inspect an image

    GET /images/(name)/json

    Get the history of an image

    GET /images/(name)/history

    Push an image on the registry

    POST /images/(name)/push

     

     

    Build image from a Dockerfile

    POST /build

     

     

    Create an image

    POST /images/create

    Load a tarball with a set of images and tags into docker

    POST /images/load

     

     

    Get a tarball containing all images in a repository

    GET /images/(name)/get

     

     

    Get a tarball containing all images

    GET /images/get

     

     

    Tag an image into a repository

    POST /images/(name)/tag

     

     

    Remove an image

    DELETE /images/(name)

    Search images

    GET /images/search

     

     

    Monitor Docker’s events

    GET /events

     

     

    Show the docker version information

    GET /version

    Display system-wide information

    GET /info

    Ping the docker server

    GET /_ping

     

     

    List volumes

    GET /volumes

     

     

    Create a volume

    POST /volumes/create

     

     

    Inspect a volume

    GET /volumes/(name)

     

     

    Remove a volume

    DELETE /volumes/(name)

     

     

    List networks

    GET /networks

     

     

    Inspect network

    GET /networks/<network-id>

     

     

    Create a network

    POST /networks/create

     

     

    Remove a network

    DELETE /networks/(id)

     

     

    Connect a container to a network

    POST /networks/(id)/connect

     

     

    Disconnect a container from a network

    POST /networks/(id)/disconnect

     

     

    Check auth configuration

    POST /auth

     

     

    Exec Create

    POST /containers/(id)/exec

    Exec Start

    POST /exec/(id)/start

    Exec Resize

    POST /exec/(id)/resize

     

    Exec Inspect

    GET /exec/(id)/json

    List plugins

    GET /plugins

     

     

    Install a plugin

    POST /plugins/pull?name=<plugin name>

     

     

    Inspect a plugin

    GET /plugins/(plugin name)

     

     

    Enable a plugin

    POST /plugins/(plugin name)/enable

     

     

    Disable a plugin

    POST /plugins/(plugin name)/disable

     

     

    Remove a plugin

    DELETE /plugins/(plugin name)

     

     

    List nodes

    GET /nodes

     

     

    Inspect a node

    GET /nodes/<id>

     

     

    Remove a node

    DELETE /nodes/<id>

     

     

    Update a node

    POST /nodes/<id>/update

     

     

    Inspect swarm

    GET /swarm

     

     

    Initialize a new swarm

    POST /swarm/init

     

     

    Join an existing swarm

    POST /swarm/join

     

     

    Leave a swarm

    POST /swarm/leave

     

     

    Update a swarm

    POST /swarm/update

     

     

    List services

    GET /services

     

     

    Create a service

    POST /services/create

     

     

    Remove a service

    DELETE /services/(id or name)

     

     

    Inspect one or more services

    GET /services/(id or name)

     

     

    Update a service

    POST /services/(id or name)/update

     

     

    List tasks

    GET /tasks

     

     

    Inspect a task

    GET /tasks/(task id)

     

     

    1)       从表格中可以看到,Kubernetes1.4中调用了Docker的Resize a container TTY接口,用来配置Docker容器的虚拟终端(TTY),重新设置Docker容器的虚拟终端之后,需要重新启动容器才能生效。

    HTTP请求例子:

     

     POST/containers/4fa6e0f0c678/resize?h=40&w=80 HTTP/1.1

    返回响应例子:

     HTTP/1.1 200 OK
     Content-Length: 0
     Content-Type: text/plain; charset=utf-8

    请求参数:

    h – 虚拟终端高度

    w – 虚拟终端宽度

    HTTP返回响应状态值:

    200 – 设置成功

    404 – 没有找到指定Docker容器

    500 – 不能够重新设置虚拟终端参数

    2)       从表格中还可以看到,Kubernetes1.4中调用了Docker的Exec Resize接口,如果在Docker容器中执行exec命令时指定了虚拟终端(tty),那么通过这个API接口就可以重新设置虚拟终端(tty)。

    HTTP请求例子:

      POST/exec/e90e34656806/resize?h=40&w=80 HTTP/1.1
      Content-Type: text/plain

    返回响应例子:

      HTTP/1.1201 Created
      Content-Type: text/plain


    请求参数:

    h –虚拟终端高度

    w –虚拟终端宽度

    HTTP返回响应状态值:

    201 –设置成功

    404 –没有找到指定exec实例

    3)       Kubernetes1.4新增加了上面两个接口调用,可以看看这两个接口调用在源代码中的位置:

    func AttachContainer(client DockerInterface,containerID kubecontainer.ContainerID, stdin io.Reader, stdout, stderrio.WriteCloser, tty bool, resize <-chan term.Size) error {
    
          <span style="color:#FF0000;"> kubecontainer.HandleResizing(resize, func(size term.Size) {
    
                  client.ResizeContainerTTY(containerID.ID,int(size.Height), int(size.Width))
    
           })</span>
    
           opts:= dockertypes.ContainerAttachOptions{
    
                  Stream:true,
    
                  Stdin:  stdin != nil,
    
                  Stdout:stdout != nil,
    
                  Stderr:stderr != nil,
    
           }
    
           ……
    
    }
     
    func (*NativeExecHandler)ExecInContainer(client DockerInterface, container *dockertypes.ContainerJSON,cmd []string, stdin io.Reader, stdout, stderr io.WriteCloser, tty bool, resize<-chan term.Size) error {
    
           ……
    
          <span style="color:#FF0000;"> kubecontainer.HandleResizing(resize, func(size term.Size) {
    
                  client.ResizeExecTTY(execObj.ID, int(size.Height),int(size.Width))
    
           })</span>
    
           startOpts:= dockertypes.ExecStartCheck{Detach: false, Tty: tty}
    
           streamOpts:= StreamOptions{
    
                  InputStream:  stdin,
    
                  OutputStream:stdout,
    
                  ErrorStream:  stderr,
    
                  RawTerminal:  tty,
    
           }
    
           err= client.StartExec(execObj.ID, startOpts, streamOpts)
    
           iferr != nil {
    
                  returnerr
    
           }
    
    ……
    
    }


    这两处开发开发人员的注释如下:

    Have to start this before the call toclient.AttachToContainer because client.AttachToContainer is a blocking call:-( Otherwise, resize events don't get processed and the terminal neverresizes. 

    Have to start this before the call toclient.StartExec because client.StartExec is a blocking call :-( Otherwise,resize events don't get processed and the terminal never resizes.

     通过注释可以发现,因为attach和start exec两个接口都是可以阻塞的,所以通过增加设置虚拟终端(tty)来判断向attach和start exec两个接口发送的请求是否阻塞。

    4)       从表格中还可以看到,Kubernetes没有使用到Docker的网络接口,也没有使用到Docker的卷接口,原因是Kubernetes自己定义了Service和POD,自己实现了POD之间的网络和挂载到POD上的卷。

    5)       从表格中也可以看到,Kubernetes对Docker容器的管理只有很少的功能,甚至都没有使用到Docker的重启接口,还是因为Kubernetes自己定义的POD,Kubernetes以POD为基本操作单元,而且是Kubernetes从容器集群管理角度设计的,所以不存在对POD里面单个Docker容器的重启操作。

    (四)对Docker其他操作

    1)       Linux ext4文件系统要求文件名字符个数不能超过255,在Kubernetes1.4中进行了控制。

    2)       由于Docker1.12支持了通过—sysctl参数来设置内核参数,所以在Kubernetes1.4可以将安全的sysctl命令放入白名单列表中,这样就可以对容器内核参数进行配置操作,下面是Kubernetes1.4对内核参数的默认设置:

    •       sysctl -wvm.overcommit_memory=1

    表示节点上有多少物理内存就用多少,不进行内存超分配

    •       sysctl -w vm.panic_on_oom=0

    表示当节点上物理内存耗尽时,内核触发OOM killer杀掉最耗内存的进程

    •       sysctl -w kernel/panic=10

    表示当内核panic时,等待10秒后在重启

    •       sysctl -wkernel/panic_on_oops=1

    设置当内核oops发生时,采用panic方式处理。不同于panic会导致OS重启,设备驱动引发的oops通常不会导致OS重启,但是可以通过设置这个参数来指定oops发生时进行OS重启

    (五)K8S操作Docker的网络实现

    我们可以用下面这张图来把POD和容器之间的关系形象化,此图仅供说明问题时的参考,并无实际意义。


    我们可以把POD看作是机器里面的操作系统,把容器看作是里面的进程,在操作系统内部进程间是可以通过IPC(Inter-Process Communication)进行通讯的,不同操作系统之间的进程是通过操作系统IP和端口进行通讯的,那么对应到POD和容器,就变成了POD内部容器间事可以通过IPC(Inter-Process Communication)进行通讯的,不同POD之间的容器是通过POD IP和端口进行通讯的。从集群的角度来考虑问题,Kubernetes基本操作单元是POD,不需要关注到POD中的容器,那么我们可以想象一下,如果我们要按照虚拟机的使用方式来使用容器,那样的话应该如何使用Kubernetes呢?可以看下面的图:


    这样我们就实现了像虚拟机那样使用容器,我们可以认为POD就是一个虚拟机,只不过在这个虚拟机中只有一个容器。但是如果要对这个虚拟机进行操作的时候我们发现问题来了,从前面的表格中可以看到,Kubernetes对Docker容器的管理只有很少的功能,没有使用到Docker的重启接口,但是如果把容器当作虚拟机用,必然要使用重启功能,抛开Kubernetes的设计理念,我们自己可以扩展Kubernetes对POD重启的实现,实现把容器当作虚拟机来使用的需求。

    展开全文
  • Docker 是什么 如何使用 Docker 制作 Java镜像 使用Dockerfile构建 Java镜像 使用Docker Registry 管理镜像 Spring Boot 与Docker 集成 Jenkins+Docker+Git实现自动化打包 首先...

    最终目标 :

    1. Docker 是什么

    2. 如何使用 Docker

    3. 制作 Java镜像

    4. 使用 Dockerfile构建 Java镜像

    5. 使用 Docker Registry 管理镜像

    6. Spring Boot 与 Docker 集成

    7. Jenkins+Docker+Git实现自动化打包

    首先了解下Docker 是什么,有什么作用

    Docker 官网 : http//www.docker.com/

    Docker 源码地址: http//github.com/docker/docker

    Docker 是基于 Go语言开发,性能非常优秀.

    简单来说就是将服务以及运行环境加以封装,确保封装后的产物作为交付物,这个交付物可以随时构建,装载,运行.

     Docker核心概念(什么是Docker引擎?什么是Docker容器?)

             类似我们曾经使用的光盘能在上面刻录数据,然后只需将光盘放入光驱中就能读取数据,同样我们只需获取Docker 镜像就能将其载入到Docker 引擎中并运行镜像.首先我们需要将数据打包到镜像中才能将Docker镜像交给其他人使用

              可随时运行Docker镜像,启动一个Docker容器,该容器将运行镜像中封装的程序

             官方提供了一个Docker Hub的镜像注册中心,用于存放公开和私有的Docker 镜像仓库. 我们可随时通过Docker Hub拉取Docker镜像,也可以自由将自己创建的Docker镜像推送到Docker Hub上

         Docker Hub地址: https://hub.docker.com/    Docker官方已将注册中心核心组件Docker Registry进行开源,可搭建内网镜像中心

    1. Docker 引擎(Docker Engine)
      可以理解为一个运行在服务器上的后台进程,本质上就是一个服务,可通过docker命令客户端发送命令与Docker引擎通信.
    2. Docker 客户端(Docker Client)
      Docker 客户端有两种,一种是Docker 命令客户端,只要打开命令终端窗口输入Docker 命令就能操作Docker 引擎, 另一种是REST API客户端,一般会在应用程序中通过Api与Docker引擎发送交互
    3. Docker 镜像(Docker Images)
    4. Docker 容器(Docker Containers)
    5. Docker 镜像注册中心(Docker Registry)

    虚拟机与Docker对比

            Docker 本质上为我们提供了一个"沙箱(Sandbox)"环境,它能将应用程序进行封装,并提供与虚拟机相似的隔离性,这种隔离性相当轻量.虚拟机软件需要模拟硬件与网络资源,会占用大量的系统开销(一台普通服务器最多启动几十个虚拟机).使用Docker 来实现虚拟化技术只需先在宿主机上安装一个Docker引擎,就可下载所需的docker镜像,Docker引擎完全利用宿主机的硬件与网络资源,占用的系统开销较少(一台普通服务器可启动上千个Docker容器)

        

    Docker 的特点

    Docker 是通过底层上封装了 Linux 容器技术来实现的并没有创建任何新技术,但Docker具有 快速运行(启动快只需几秒),节省资源(系统开销少),便于交互(包含服务与运行环境),容易管理的特点

    Docker 系统架构 

     

    • Client : 表示Docker客户端,可通过 docker build 命令创建 Docker镜像;docker pull 拉取镜像;Docker run运行而启动镜像
    • DOCKER_HOST: 运行Docker引擎的宿主机,其中包括 Docker Daemon 后台进程,可通过该进程来创建Docker 镜像,并在Docker镜像上启动Docker 容器
    • Registry: 表示Docker 官方镜像注册中心,其中包含了大量的Docker 镜像仓库,可通过引擎拉取所需的镜像到宿主机上

    Docker 安装

    Docker官方建议我们将Docker 引擎运行在Linux 操作系统上.当然也可以运行在 Mac OSX 和windows 上,生产环境不推荐使用

    这里介绍在 CentOS 中安装 Docker,Mac OSX 和windows环境使用较少这里不介绍,个人学习或研究请安装Docker for Mac

    安装条件:

    1. CPU 必须为 64 位
    2. Linux 内核必须在3.10版本以上
    3. 可使用uname -a命令获取以上版本信息

    安装步骤:

    1. 使用VM或VirtualBox安装centos 7及简单的网络配置

    2. 更新yum包,为了安装最新版本的Docker我们需要使用 yum update 命令更新yum 包

    3. 添加 yum的Docker包仓库

    4. 安装 Docker引擎  使用命令 yum install docker-engine

    5. 启动 Docker 引擎 , Docker引擎安装完毕后使用命令 service docker start 启动Docker引擎服务

    6. 查看Docker 版本好  使用 docker version 命令 

      两种安装方式
      
      yum安装 
      1.更新yum包 
      $ sudo yum update 
      2.添加yum仓库 
      $ sudo tee /etc/yum.repos.d/docker.repo <<-‘EOF’ 
      [dockerrepo] 
      name=Docker Repository 
      baseurl=https://yum.dockerproject.org/repo/main/centos/7/ 
      enabled=1 
      gpgcheck=1 
      gpgkey=https://yum.dockerproject.org/gpg 
      EOF 
      3.安装docker包 
      $ sudo yum install docker-engine 
      4.运行docker后台进程 
      $ sudo service docker start 
      5.检测docker是否正确安装 
      $ sudo docker run hello-world
      脚本安装 
      1.更新yum包 
      $ sudo yum update 
      2.运行docker安装脚本 
      $ curl -fsSL https://get.docker.com/ | sh 
      3.运行docker后台进程 
      $ sudo service docker start 
      4.检测docker是否正确安装 
      $ sudo docker run hello-world

       

    推荐使用脚本安装方式 ,文章都是个人阅读资料后总结有误之处请大家斧正,后面会持续更新敬请关注!

    展开全文
  • Docker技术实战

    2020-08-30 14:29:40
    课程详细地把Docker的基础知识点,技术点梳理清楚,然后加以练习实战,最后部署一个数据库,redis缓存,前段,后端都集群,并实现均衡负载,高可用,双机热备等特性的综合项目。
  • Docker技术特性可以为IT团队带来怎样的价值呢?睿云智合(Wise2C)作为容器技术的领先者为你解开Docker技术所带来的价值。 Docker技术特性可以为IT团队带来以下价值: 1.通过以docker镜像为基础的标准化封装与...
  • Docker是基于Linux Container(LXC)技术实现的一个轻量级虚拟化解决方案,用户可以直接使用容器(Container),来构建自己的应用程序,应用开发人员无需将注意力集中在容器的管理上。Docker的目标是
  • Docker技术文档

    2017-05-14 20:23:52
    Docker技术文档这是关于docker虚拟化技术的文档。
  • Docker技术基础

    2019-10-05 10:44:08
    Docker技术基础 1、Docker技术基础 对进程做隔离。隔离CPU和内存,限制命名空间 Docker是分层的 Containerd是核心组件 Docker Client实现到Docker Engine之间通信  主要关注:  con...
  • Docker技术学习

    2021-04-03 23:00:22
    1.Docker常用的基础概念 Docker 镜像 Docker 容器 Docker 仓库 什么是Docker? Docker的优点 2.Docker的安装 前置条件 Ubuntu CentOS Debian MAC 3.Docker镜像及容器的使用 搜索镜像 获取镜像 查看...
  • Docker技术分享

    2020-07-01 08:47:50
    Docker从2013年发布至今,一直备受瞩目,被认为可能会改变软件行业。 但是,许多人并不清楚Docker到底是什么,要解决什么问题,好处又在哪里?本次分享会详细解释,帮助大家理解它,并且还有简单易懂的实例,教你...
  • Docker技术研究

    2020-05-30 10:52:21
    文章目录一、Docker入门1.Docker对比虚拟机1.镜像查看所有镜像docker打标签查看镜像的详细信息只搜索关注度1000以上的镜像删除镜像导出镜像导入镜像上传镜像2.容器新建容器新建并启动容器守护态运行仅仅简单启动容器...
  • docker技术简介

    2018-02-01 16:56:35
    翻译自docker官方文档,原文地址:https://docs.docker.com/engine/docker-overview/ Docker概述 docker是一个用于开发,传递和运行应用程序的开放平台。docker使你可以把应用和物理设施隔离开因此你可以快速...
  • Docker容器技术与传统的虚拟机技术特性对比
  • 在开发和运维中,为什么要使用docker:更快速的交付和部署更高效的资源利用更轻松的迁移和部署更简单的更新管理下表是Docker容器技术和传统虚拟机技术特性比较比较特性容器虚拟机启动速度妙级分钟级性能接近原...
  • 及使用Spring Boot集成Dubbo、Mybatis等开源框架,其中穿插着Spring Boot中日志切面等技术的实现,然后通过gitlab-CI以持续集成为Docker镜像。 本系列文章中所使用的框架版本为Spring Boot 2.0.3-RELEASE,...
  • Docker技术入门

    2018-06-21 15:30:54
    Docker的构想是要实现“Build, Ship and Run Any App, Anywhere”,即通过对应用的封装(Packaging)、分发(Distribution)、部署(Deployment)、运行(Runtime)生命周期进行管理,达到应用组件“**一次封装,...
  • Docker容器技术

    2019-09-03 17:49:55
    文章目录Docker容器技术docker的安装docker的使用Docker Images镜像管理镜像相关操作基于容器制作镜像推送仓库到远程服务器镜像导入和导出docker容器虚拟化网络四种网络模型的创建docker网络相关配置docker存储卷 ...
  • Docker技术入门与实战

    2020-08-01 19:33:54
    Docker技术入门与实战 下载地址 https://pan.baidu.com/s/1bAoRQQlvBa-PXy5lgIlxUg 扫码下面二维码关注公众号回复100011 获取分享码 本书目录结构如下: 第一部分 基础入门 第1章 初识容器与Docker 1.1 ...
  • Docker1.11新特性

    万次阅读 2016-04-26 12:40:09
    本次分析的Docker版本号:v1.11.0。我们来看daemon模块,daemon模块核心的结构体是Daemon,同v1.10.0相比增加了containerd和defaultIsolation两个变量,删除了execDriver变量。
  • docker介绍,安装和常用命令。传统虚拟化需要硬件模拟或者操作系统软件实现,而容器技术充分利用操作系统本身的机制和特性,实现远超传统虚拟机的轻量级虚拟化。
  • Docker 技术入门

    2019-08-22 16:29:16
    Docker是什么? 我们在理解docker之前,首先我们得先区分清楚两个概念,容器和虚拟机。 可能很多读者朋友都用过虚拟机,而对容器这个概念比较的陌生。 我们用的传统虚拟机如VMware,VisualBox之类的需要模拟整台...
  • 于Ubuntu Xenial Puppet代理程序包,另一个基于简化版的Alpine。...Blueshift包含Puppet社区中关于如何集成Consul、CoreOS和Mesos等技术的信息。Blueshift还包含Puppet的内部工程。 Puppet还提供...
  • 本课程的目标在于为企业级的开发、运维环境中使用 Docker 提供实战型指导,为你深入浅出地讲解 Docker 容器技术,以便大家课后可以在线下自己实践 Docker 技术。 作者简介 肖德时,十五年计算机行业从业经验,曾为...
  • Docker Swarm新特性

    2016-08-02 10:36:54
    本文将系统性的介绍Swarm及其新特性,如果你想全面了解Docker Swarm,学习本文及后续文章将是您很好的选择!
  • docker镜像的特性

    2020-07-27 23:28:26
    镜像的分层:Docker 的镜像通过联合文件系统( union filesystem ) 将各层文件系统叠加在一起 bootfs:用于系统引导的文件系统,包括bootloader 和kernel,容器启动完成后会被卸载以节省内存资源 roofs:位于bootf
  • docker DockerFile技术

    千次阅读 2020-09-01 09:51:50
    什么是docker DockerFile技术 Docker通过读取Dockerfile里面的内容可以自动build image,Dockerfile是一个包含了build过程中需要执行的所有命令的文本文件。也可以理解为Dockfile是一种被Docker程序解释的脚本,由...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 36,484
精华内容 14,593
关键字:

docker技术特性