docker 订阅
Docker 是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中,然后发布到任何流行的 Linux或Windows 机器上,也可以实现虚拟化。容器是完全使用沙箱机制,相互之间不会有任何接口。 [1] 展开全文
Docker 是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中,然后发布到任何流行的 Linux或Windows 机器上,也可以实现虚拟化。容器是完全使用沙箱机制,相互之间不会有任何接口。 [1]
信息
编程语言
Go
类    别
操作系统层虚拟化
提供商
Docker,Inc.
许可协议
Apache License 2.0
中文名
应用容器引擎
发行日期
2013年
外文名
Docker
Docker简介
Docker 是一个开源的应用容器引擎,让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux机器或Windows 机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。一个完整的Docker有以下几个部分组成:Docker 是 PaaS 提供商 dotCloud 开源的一个基于 LXC 的高级容器引擎,源代码托管在 Github 上, 基于go语言并遵从Apache2.0协议开源。Docker自2013年以来非常火热,无论是从 github 上的代码活跃度,还是Redhat在RHEL6.5中集成对Docker的支持, 就连 Google 的 Compute Engine 也支持 docker 在其之上运行。一款开源软件能否在商业上成功,很大程度上依赖三件事 - 成功的 user case(用例), 活跃的社区和一个好故事。 dotCloud 之家的 PaaS 产品建立在docker之上,长期维护且有大量的用户,社区也十分活跃,接下来我们看看docker的故事。 面对上述几个问题,docker设想是交付运行环境如同海运,OS如同一个货轮,每一个在OS基础上的软件都如同一个集装箱,用户可以通过标准化手段自由组装运行环境,同时集装箱的内容可以由用户自定义,也可以由专业人员制造。这样,交付一个软件,就是一系列标准化组件的集合的交付,如同乐高积木,用户只需要选择合适的积木组合,并且在最顶端署上自己的名字(最后一个标准化组件是用户的app)。这也就是基于docker的PaaS产品的原型。Docker 使用客户端-服务器 (C/S) 架构模式,使用远程API来管理和创建Docker容器。Docker 容器通过 Docker 镜像来创建。容器与镜像的关系类似于面向对象编程中的对象与类。 [3]  Docker采用 C/S架构 Docker daemon 作为服务端接受来自客户的请求,并处理这些请求(创建、运行、分发容器)。 客户端和服务端既可以运行在一个机器上,也可通过 socket 或者RESTful API 来进行通信。Docker daemon 一般在宿主主机后台运行,等待接收来自客户端的消息。 Docker 客户端则为用户提供一系列可执行命令,用户用这些命令实现跟 Docker daemon 交互。 [4]  在docker的网站上提到了docker的典型场景:由于其基于LXC的轻量级虚拟化的特点,docker相比KVM之类最明显的特点就是启动快,资源占用小。因此对于构建隔离的标准化的运行环境,轻量级的PaaS(如dokku), 构建自动化测试和持续集成环境,以及一切可以横向扩展的应用(尤其是需要快速启停来应对峰谷的web应用)。Docker并不是全能的,设计之初也不是KVM之类虚拟化手段的替代品,简单总结几点:针对1-2,有windows base应用的需求的基本可以pass了; 3-5主要是看用户的需求,到底是需要一个container还是一个VM, 同时也决定了docker作为 IaaS 不太可行。针对6,7虽然是docker本身不支持的功能,但是可以通过其他手段解决(disk quota, mount --bind)。总之,选用container还是vm, 就是在隔离性和资源复用性上做权衡。另外即便docker 0.7能够支持非AUFS的文件系统,但是由于其功能还不稳定,商业应用或许会存在问题,而AUFS的稳定版需要kernel 3.8, 所以如果想复制dotcloud的成功案例,可能需要考虑升级kernel或者换用ubuntu的server版本(后者提供deb更新)。这也是为什么开源界更倾向于支持ubuntu的原因(kernel版本) Docker并非适合所有应用场景,Docker只能虚拟基于Linux的服务。Windows Azure 服务能够运行Docker实例,但到目前为止Windows服务还不能被虚拟化。可能最大的障碍在于管理实例之间的交互。由于所有应用组件被拆分到不同的容器中,所有的服务器需要以一致的方式彼此通信。这意味着任何人如果选择复杂的基础设施,那么必须掌握应用编程接口管理以及集群工具,比如Swarm、Mesos或者Kubernets以确保机器按照预期运转并支持故障切换。Docker在本质上是一个附加系统。使用文件系统的不同层构建一个应用是有可能的。每个组件被添加到之前已经创建的组件之上,可以比作为一个文件系统更明智。分层架构带来另一方面的效率提升,当你重建存在变化的Docker镜像时,不需要重建整个Docker镜像,只需要重建变化的部分。可能更为重要的是,Docker旨在用于弹性计算。每个Docker实例的运营生命周期有限,实例数量根据需求增减。在一个管理适度的系统中,这些实例生而平等,不再需要时便各自消亡了。针对Docker环境存在的不足,意味着在开始部署Docker前需要考虑如下几个问题。首先,Docker实例是无状态的。这意味着它们不应该承载任何交易数据,所有数据应该保存在数据库服务器中。其次,开发Docker实例并不像创建一台虚拟机、添加应用然后克隆那样简单。为成功创建并使用Docker基础设施,管理员需要对系统管理的各个方面有一个全面的理解,包括Linux管理、编排及配置工具比如Puppet、Chef以及Salt。这些工具生来就基于命令行以及脚本。 [5]  Docker核心解决的问题是利用LXC来实现类似VM的功能,从而利用更加节省的硬件资源提供给用户更多的计算资源。同VM的方式不同, LXC 其并不是一套硬件虚拟化方法 - 无法归属到全虚拟化、部分虚拟化和半虚拟化中的任意一个,而是一个操作系统级虚拟化方法, 理解起来可能并不像VM那样直观。所以我们从虚拟化到docker要解决的问题出发,看看他是怎么满足用户虚拟化需求的。用户需要考虑虚拟化方法,尤其是硬件虚拟化方法,需要借助其解决的主要是以下4个问题:LXC所实现的隔离性主要是来自kernel的namespace, 其中pid, net, ipc, mnt, uts 等namespace将container的进程, 网络, 消息, 文件系统和hostname 隔离开。pid namespace之前提到用户的进程是lxc-start进程的子进程, 不同用户的进程就是通过pidnamespace隔离开的,且不同 namespace 中可以有相同PID。具有以下特征:正是因为以上的特征,所有的LXC进程在docker中的父进程为docker进程,每个lxc进程具有不同的namespace。同时由于允许嵌套,因此可以很方便的实现 LXC in LXCnet namespace有了 pid namespace, 每个namespace中的pid能够相互隔离,但是网络端口还是共享host的端口。网络隔离是通过netnamespace实现的,每个net namespace有独立的 network devices, IP addresses, IP routing tables, /proc/net 目录。这样每个container的网络就能隔离开来。LXC在此基础上有5种网络类型,docker默认采用veth的方式将container中的虚拟网卡同host上的一个docker bridge连接在一起。ipc namespacecontainer中进程交互还是采用linux常见的进程间交互方法(interprocess communication - IPC), 包括常见的信号量、消息队列和共享内存。然而同VM不同,container 的进程间交互实际上还是host上具有相同pid namespace中的进程间交互,因此需要在IPC资源申请时加入namespace信息 - 每个IPC资源有一个的 32bit ID。mnt namespace类似chroot,将一个进程放到一个特定的目录执行。mnt namespace允许不同namespace的进程看到的文件结构不同,这样每个 namespace 中的进程所看到的文件目录就被隔离开了。同chroot不同,每个namespace中的container在/proc/mounts的信息只包含所在namespace的mount point。uts namespaceUTS(“UNIX Time-sharing System”) namespace允许每个container拥有独立的hostname和domain name,   使其在网络上可以被视作一个独立的节点而非Host上的一个进程。user namespace每个container可以有不同的 user 和 group id, 也就是说可以以container内部的用户在container内部执行程序而非Host上的用户。有了以上6种namespace从进程、网络、IPC、文件系统、UTS和用户角度的隔离,一个container就可以对外展现出一个独立计算机的能力,并且不同container从OS层面实现了隔离。   然而不同namespace之间资源还是相互竞争的,仍然需要类似ulimit来管理每个container所能使用的资源 - LXC 采用的是cgroup。 [6]  cgroups 实现了对资源的配额和度量。 cgroups 的使用非常简单,提供类似文件的接口,在 /cgroup目录下新建一个文件夹即可新建一个group,在此文件夹中新建task文件,并将pid写入该文件,即可实现对该进程的资源控制。具体的资源配置选项可以在该文件夹中新建子 subsystem ,{子系统前缀}.{资源项} 是典型的配置方法,如memory.usage_in_bytes 就定义了该group 在subsystem memory中的一个内存限制选项。另外,cgroups中的 subsystem可以随意组合,一个subsystem可以在不同的group中,也可以一个group包含多个subsystem - 也就是说一个 subsystem。关于术语定义A *cgroup* associates a set of tasks with a set of parameters for one   or more subsystems.   A *subsystem* is a module that makes use of the task grouping   facilities provided by cgroups to treat groups of tasks in   particular ways. A subsystem is typically a "resource controller" that   schedules a resource or applies per-cgroup limits, but it may be   anything that wants to act on a group of processes, e.g. a   virtualization subsystem.我们主要关心cgroups可以限制哪些资源,即有哪些subsystem是我们关心。cpu : 在cgroup中,并不能像硬件虚拟化方案一样能够定义CPU能力,但是能够定义CPU轮转的优先级,因此具有较高CPU优先级的进程会更可能得到CPU运算。   通过将参数写入cpu.shares,即可定义改cgroup的CPU优先级 - 这里是一个相对权重,而非绝对值。当然在cpu这个subsystem中还有其他可配置项,手册中有详细说明。cpusets : cpusets 定义了有几个CPU可以被这个group使用,或者哪几个CPU可以供这个group使用。在某些场景下,单CPU绑定可以防止多核间缓存切换,从而提高效率memory : 内存相关的限制blkio : block IO相关的统计和限制,byte/operation统计和限制(IOPS等),读写速度限制等,但是这里主要统计的都是同步IOnet_cls, cpuacct , devices , freezer 等其他可管理项。 [7]  借助于namespace的隔离机制和cgroup限额功能,LXC提供了一套统一的API和工具来建立和管理container, LXC利用了如下 kernel 的features: [8]  LXC 向用户屏蔽了以上 kernel 接口的细节, 提供了如下的组件大大简化了用户的开发和使用工作:LXC 旨在提供一个共享kernel的 OS 级虚拟化方法,在执行时不用重复加载Kernel, 且container的kernel与host共享,因此可以大大加快container的 启动过程,并显著减少内存消耗。在实际测试中,基于LXC的虚拟化方法的IO和CPU性能几乎接近 baremetal 的性能 [9]  , 大多数数据有相比 Xen具有优势。当然对于KVM这种也是通过Kernel进行隔离的方式, 性能优势或许不是那么明显, 主要还是内存消耗和启动时间上的差异。在参考文献 [10]  中提到了利用iozone进行 Disk IO吞吐量测试KVM反而比LXC要快,而且笔者在device mapping driver下重现同样case的实验中也确实能得到如此结论。参考文献从网络虚拟化中虚拟路由的场景(网络IO和CPU角度)比较了KVM和LXC, 得到结论是KVM在性能和隔离性的平衡上比LXC更优秀 - KVM在吞吐量上略差于LXC, 但CPU的隔离可管理项比LXC更明确。关于CPU, DiskIO, network IO 和 memory 在KVM和LXC中的比较还是需要更多的实验才能得出可信服的结论。Docker对container的使用基本是建立在LXC基础之上的,然而LXC存在的问题是难以移动 - 难以通过标准化的模板制作、重建、复制和移动 container。在以VM为基础的虚拟化手段中,有image和snapshot可以用于VM的复制、重建以及移动的功能。想要通过container来实现快速的大规模部署和更新, 这些功能不可或缺。Docker 正是利用AUFS来实现对container的快速更新 - 在docker0.7中引入了storage driver, 支持AUFS, VFS, device mapper, 也为BTRFS以及ZFS引入提供了可能。 但除了AUFS都未经过dotcloud的线上使用,因此我们还是从AUFS的角度介绍。AUFS (AnotherUnionFS) 是一种 Union FS, 简单来说就是支持将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)的文件系统, 更进一步地, AUFS支持为每一个成员目录(AKA branch)设定'readonly', 'readwrite' 和 'whiteout-able' 权限, 同时AUFS里有一个类似分层的概念, 对 readonly 权限的branch可以逻辑上进行修改(增量地, 不影响readonly部分的)。通常 Union FS有两个用途, 一方面可以实现不借助 LVM, RAID 将多个disk和挂在到一个目录下, 另一个更常用的就是将一个readonly的branch和一个writeable的branch联合在一起,Live CD正是基于此可以允许在 OS image 不变的基础上允许用户在其上进行一些写操作。Docker在AUFS上构建的container image也正是如此,接下来我们从启动container中的linux为例介绍docker在AUFS特性的运用。 典型的Linux启动到运行需要两个FS - bootfs + rootfs (从功能角度而非文件系统角度)(图1)bootfs (boot file system) 主要包含 bootloader 和 kernel, bootloader主要是引导加载kernel, 当boot成功后 kernel 被加载到内存中后 bootfs就被umount了.rootfs (root file system) 包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs 如下(图2): 典型的Linux在启动后,首先将 rootfs 置为 readonly, 进行一系列检查, 然后将其切换为 “readwrite” 供用户使用。在docker中,起初也是将 rootfs 以readonly方式加载并检查,然而接下来利用 union mount 的将一个 readwrite 文件系统挂载在 readonly 的rootfs之上,并且允许再次将下层的 file system设定为readonly 并且向上叠加, 这样一组readonly和一个writeable的结构构成一个container的运行目录, 每一个被称作一个Layer。如下(图3):得益于AUFS的特性, 每一个对readonly层文件/目录的修改都 只会存在于上层的writeable层中。这样由于不存在竞争, 多个container可以共享readonly的layer。所以docker将readonly的层称作 “image” - 对于container而言整个rootfs都是read-write的,但事实上所有的修改都写入最上层的writeable层中,image不保存用户状态,可以用于模板、重建和复制。(图4、5) 上层的image依赖下层的image,因此docker中把下层的image称作父image,没有父image的image称作base image (图6)因此想要从一个image启动一个container,docker会先加载其父image直到base image,用户的进程运行在writeable的layer中。所有parent image中的数据信息以及ID、网络和lxc管理的资源限制等具体container的配置,构成一个docker概念上的container。如下(图7):由此可见,采用AUFS作为docker的container的文件系统,能够提供如下好处: 1.节省存储空间 - 多个container可以共享base image存储2.快速部署 - 如果要部署多个container,base image可以避免多次拷贝3.内存更省 - 因为多个container共享base image, 以及OS的disk缓存机制,多个container中的进程命中缓存内容的几率大大增加4.升级更方便 - 相比于 copy-on-write 类型的FS,base-image也是可以挂载为可writeable的,可以通过更新base image而一次性更新其之上的container5.允许在不更改base-image的同时修改其目录中的文件 - 所有写操作 都发生在最上层的writeable层中,这样可以大大增加base image能共享的文件内容。以上5条 1-3 条可以通过 copy-on-write 的FS实现, 4可以利用其他的union mount方式实现, 5只有AUFS实现的很好。这也是为什么Docker一开始就建立在AUFS之上。由于AUFS并不会进入linux主干 (According to Christoph Hellwig, linux rejects all union-type filesystems but UnionMount.),   同时要求kernel版本3.0以上(docker推荐3.8及以上),因此在RedHat工程师的帮助下在docker0.7版本中实现了driver机制, AUFS只是其中的一个driver, 在RHEL中采用的则是Device Mapper的方式实现的container文件系统。grsec是linux kernel安全相关的patch, 用于保护host防止非法入侵。由于其并不是docker的一部分,我们只进行简单的介绍。grsec可以主要从4个方面保护进程不被非法入侵:安全永远是相对的,这些方法只是告诉我们可以从这些角度考虑container类型的安全问题可以关注的方面。
收起全文
精华内容
参与话题
问答
  • docker

    万次阅读 多人点赞 2017-12-05 17:36:29
    应用场景 给你一台笔记本,笔记本的系统是windows的,如果想使用linux系统,那么得在...如果用了docker技术,那么就可以建成千上万个docker容器,一个docker容器就相当于一个linux虚拟机,它可以将计算机资源利用

    应用场景

    给你一台笔记本,笔记本的系统是windows的,如果想使用linux系统,那么得在windows上安装虚拟机,然后安装linux系统,一般一台8G内存的笔记本,可以建并启动6-7个1G内存的linux虚拟机,如果再创建并启动虚拟机那么电脑将无法承受,如果用了docker技术,那么就可以建成千上万个docker容器,一个docker容器就相当于一个linux虚拟机,它可以将计算机资源利用最大化,效率化,所以docker是一个虚拟的技术。

    docker概述

    1.1 docker简介

    Docker 是 2014 年最为火爆的技术之一,几乎所有的程序员都听说过它。Docker 是一种“轻量级”容器技术,几乎动摇了传统虚拟化技术的地位,现在国内外已经有越来越多的公司开始逐步使用 Docker 来替换现有的虚拟化平台了。

    先来回顾一下传统虚拟化技术的体系架构:

    这里写图片描述

    可见,我们在宿主机的操作系统上,可安装多个虚拟机,而在每个虚拟机中,通过虚拟化技术,实现了一个虚拟操作系统,随后,就可以在该虚拟操作系统上,安装自己所需的应用程序了。

    我们知道,启动虚拟机就像启动一台计算机,初始化过程是相当慢的,需要等很久,才能看到登录界面。一旦虚拟机启动以后,就可以与宿主机建立网络连接,确保虚拟机与宿主机之间是互联互通的。不同的虚拟机之间却是相互隔离的,也就是说,彼此并不知道对方的存在,但每个虚拟机占用的都是宿主机的硬件与网络资源。

    我们再来对比一下 Docker 技术的体系架构吧:

    这里写图片描述

    可见,在宿主机的操作系统上,有一个 Docker 服务在运行(或者称为“Docker 引擎”),在此服务上,我们可开启多个 Docker 容器,而每个 Docker 容器中可运行自己所需的应用程序,Docker 容器之间也是相互隔离的,同样地,都是占用的宿主机的硬件与网络资源。

    Docker 容器相对于虚拟机而言,除了在技术实现上完全不一样以外,启动速度较虚拟机而言有本质的飞跃,启动一个容器只在眨眼瞬间。不管是虚拟机还是 Docker 容器,它们都是为了隔离应用程序的运行环境,节省我们的硬件资源,为我们开发人员提供福利。

    我们再来看看 Docker 的 Logo 吧:

    这里写图片描述

    很明显,这是一只鲸鱼,它托着许多集装箱。我们可以把宿主机可当做这只鲸鱼,把相互隔离的容器可看成集装箱,每个集装箱中都包含自己的应用程序。

    1.2 docker应用

    docker能干些什么?

    • 1、加速本地开发(通过Docker能够快速搭建好开发和运行环境,并且该环境可以直接传递给测试和产品部署)
    • 2、自动打包和部署应用
    • 3、创建轻量、私有的PasS环境(例子:http://www.alauda.cn/,比如在林雀云上创建了centos7,本地就能进入虚拟机访问容器)
    • 4、自动化测试和持续集成部署
    • 5、部署并扩展Web应用、数据库和后端服务
    • 6、创建安全沙盒(使容器隔离)
    • 7、轻量级的桌面虚拟化(虚拟桌面,做为一个镜像进行管理,例子https://www.shiyanlou.com/课程里,给每个用户每堂课准备一台虚拟机,都是docker虚拟化的)。

    1.3 docker三大核心

    另外,docker主要包括三大核心概念,理解了这三个核心概念,就能理解docker的整个生命周期:

    • 1、镜像:类似于虚拟机镜像,可以将它理解为一个面向Docker引擎的只读模板,包含了文件系统,镜像是创建Docker容器的基础。
    • 2、容器:类似于一个轻量级的沙箱,Docker利用容器来运行和隔离应用。容器是从镜像的应用运行实例,可以将其启动,开始,停止,删除,而这些容器都是相互隔离,互不可见的。镜像自身是只读的,容器从镜像启动的时候,Docker会在镜像的最上层创建一个可写层,镜像本身保持不变。
    • 3、仓库:类似于代码仓库,是docker集中存放镜像文件的场所。

    环境准备

    2.1 环境配置

    试验环境为:windows7系统,内存8G,固态硬盘120G,硬盘450G,ip为192.168.117.66,在windows7系统上,安装VMware,创建两个虚拟机,安装centos7.1系统,两个虚拟机内存2G,硬盘30G,ip分别为192.168.199.31(docker1),192.168.199.32(docker2)。

    Docker私有仓库地址:192.168.199.31 hostname:docker1
    Docker客户端地址: 192.168.199.32 hostname:docker2

    2.2 配置虚拟机

    首先在本地windows环境安装vmware,然后创建两个虚拟机,安装centos7.1系统(可以用centos6.5,但是需要升级内核,比较繁琐,还是用7.1好,一步到位,并且centos6.5和centos7.1安装docker以后的文件名,文件地址都不一样,可能和后文的操作不同,建议centos7.1),装好以后需要配置网路,主机名,关闭防火墙等,操作如下。

    2.2.1. 修改hostname

    安装完虚拟机,进入centos7.1系统后,进入控制台,由于centos7.1的命令与centos6.5等,有所区别,这里修改hostname输入如下命令:

     # sudo hostnamectl --static set-hostname  <host-name> 
    

    上面命令的host-name根据文中设置为docker1,另一个设置为docker2。

    2.2.2. 关闭防火墙

    关闭防火墙输入如下命令:
    
     # systemctl stop firewalld
    
    禁用防火墙输入如下命令:
    
     # systemctl disable firewalld
    

    2.2.3. 关闭selinux

     # vi /etc/selinux/config
     
    将SELINUX=enforcing修改为SELINUX=disabled。
    

    2.2.4. 配置网络

    由于设置虚拟机网络需要确定网段,确定网段方法如下:

    • 打开VMWare

    这里写图片描述

    • 点开虚拟网络编辑器,按下图示点击

    这里写图片描述

    • 查看自己虚拟机所对应的网段

    这里写图片描述

    因此,本地试验环境的虚拟机网段是199,各台机器可能不一样,需要查看后再进行网络配置。
    配置centos7虚拟机网络,输入如下命令:

    # vi /etc/sysconfig/network-scripts/ifcfg-ens192
    
    注:最后的ipcfg-ens192文件,另一台机器可能不是个文件名,自己找虚拟机中的ifcfg-ens+一串数字的文件,进行修改。
    修改如下:
    
    TYPE=Ethernet
    BOOTPROTO=static
    DEFROUTE=yes
    PEERDNS=yes
    PEERROUTES=yes
    IPV4_FAILURE_FATAL=no
    IPV6INIT=yes
    IPV6_AUTOCONF=yes
    IPV6_DEFROUTE=yes
    IPV6_PEERDNS=yes
    IPV6_PEERROUTES=yes
    IPV6_FAILURE_FATAL=no
    NAME=eno16777736
    UUID=2d0d964b-91d1-4810-9eb7-b523689420d2
    DEVICE=eno16777736
    ONBOOT=yes
    IPADDR=192.168.199.31
    PREFIX=24
    GATEWAY=192.168.199.2
    DNS1=114.114.114.114
    
    然后重启网络:
    
     # systemctl restart network.service
    

    安装docker

    安装docker,输入如下命令:
    
     # yum install docker
     # yum upgrade device-mapper-libs
     # service docker start
     # chkconfig docker on
     
    查看docker状态:
    
     # service docker status
    
    展开全文
  • Docker集群管理三剑客

    万人学习 2015-09-06 15:21:09
    Docker集群管理视频教程,该课程主要分享Docker集群管理工具,主要包括Docker Machine、Docker Compose、Docker Swarm。Docker Machine为本地,私有数据中心及公有云平台提供Docker引擎,实现从零到Docker的一键部署...
  • Docker

    万次阅读 多人点赞 2019-10-29 23:15:26
    文章目录@[toc]dockerdocker 手册centos7 联网安装docker官方安装手册镜像加速基本概念镜像容器docker 镜像操作下载 CentOS 镜像查看centos7镜运行 centos7删除镜像镜像导出镜像导入容器操作启动容器后台运行查看...




    docker

    官网是这样介绍docker的:

    Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications…

    其实看完这句话还是不明白docker究竟是什么

    我们可以把他想象成是一个用了一种新颖方式实现的超轻量虚拟机。当然在实现的原理和应用上还是和VM有巨大差别的,并且专业的叫法是应用容器(Application Container)。

    docker

    比如现在想用MySQL,那就找个装好并配置好的MySQL的容器(可以认为是特殊的,轻量级的虚拟机),运行起来,那么就可以使用 MySQL了。

    那么为什么不直接在操作系统中安装一个mysql,而是用容器呢?

    安装MySql过程并不简单,要配置安装源,安装依赖包,对mysql进行配置…如果要在多台主机上安装,每台主机都要进行这些繁琐的操作,万一服务器挂了,这一系列操作还要再重来一遍

    但有了docker,一个安装配置好的mysql容器,可以直接拿到另一台主机上启动,而不必重新安装mysql

    另外,docker还有一重要的用处,就是可以保证开发,测试和生产环境的一致.




    docker 手册

    中文免费手册 [Docker — 从入门到实践]
    https://vuepress.mirror.docker-practice.com

    docker 从入门到实践,离线版

    docker pull dockerpracticecn/docker_practice
    docker run -it --rm -p 4000:80 dockerpracticecn/docker_practice
    




    centos7 安装docker

    离线安装包

    下载离线安装包
    https://download.csdn.net/download/weixin_38305440/12265961

    上传离线安装包

    • docker-install 目录上传到 /root

    切换到docker-install目录

    cd docker-install
    

    安装

    rpm -ivh *.rpm
    

    yum 在线安装 docker

    官方安装手册

    https://docs.docker.com/install/linux/docker-ce/centos/

    卸载旧版

    
    sudo yum remove docker-ce \
                    docker-ce-client \
                    docker-client-latest \
                    docker-common \
                    docker-latest \
                    docker-latest-logrotate \
                    docker-logrotate \
                    docker-engine
    
    

    安装一组工具

    sudo yum install -y yum-utils \
      device-mapper-persistent-data \
      lvm2
    

    设置 yum 仓库地址

    
    sudo yum-config-manager \
        --add-repo \
        https://download.docker.com/linux/centos/docker-ce.repo
        
    sudo yum-config-manager \
         --add-repo \
         http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
    

    更新 yum 缓存

    sudo yum makecache fast
    

    安装新版 docker

    sudo yum install -y docker-ce docker-ce-cli containerd.io
    

    启动docker系统服务

    启动 docker

    sudo systemctl start docker
    

    设置 docker 开机启动

    sudo systemctl enable docker
    

    镜像加速

    由于国内网络问题,需要配置加速器来加速。
    修改配置文件 /etc/docker/daemon.json

    下面命令直接生成文件 daemon.json

    cat <<EOF > /etc/docker/daemon.json
    {
      "registry-mirrors": [
        "https://dockerhub.azk8s.cn",
        "https://hub-mirror.c.163.com"
      ]
    }
    EOF
    

    之后重新启动服务。

    # 重新加载docker配置
    sudo systemctl daemon-reload
    
    #重启docker服务
    sudo systemctl restart docker
    

    查看镜像配置

    docker info
    

    运行 hello-world 镜像,验证 docker

    sudo docker run hello-world
    




    基本概念

    镜像

    Docker 镜像是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置等文件外,还包含了一些为运行时准备的一些配置参数(如匿名卷、环境变量、用户等)。镜像不包含任何动态数据,其内容在构建之后也不会被改变。

    镜像只是一个虚拟的概念,其实际体现并非由一个文件组成,而是由一组文件系统组成,或者说,由多层文件系统联合组成。

    镜像构建时,会一层层构建,前一层是后一层的基础。每一层构建完就不会再发生改变,后一层上的任何改变只发生在自己这一层。比如,删除前一层文件的操作,实际不是真的删除前一层的文件,而是仅在当前层标记为该文件已删除。在最终容器运行的时候,虽然不会看到这个文件,但是实际上该文件会一直跟随镜像。因此,在构建镜像的时候,需要额外小心,每一层尽量只包含该层需要添加的东西,任何额外的东西应该在该层构建结束前清理掉。

    分层存储的特征还使得镜像的复用、定制变的更为容易。甚至可以用之前构建好的镜像作为基础层,然后进一步添加新的层,以定制自己所需的内容,构建新的镜像。

    容器

    镜像(Image)和容器(Container)的关系,就像是面向对象程序设计中的 类 和 实例 一样,镜像是静态的定义,容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。

    容器的实质是进程,但与直接在宿主执行的进程不同,容器进程运行于属于自己的独立的 命名空间。因此容器可以拥有自己的 root 文件系统、自己的网络配置、自己的进程空间,甚至自己的用户 ID 空间。容器内的进程是运行在一个隔离的环境里,使用起来,就好像是在一个独立于宿主的系统下操作一样。这种特性使得容器封装的应用比直接在宿主运行更加安全。

    前面讲过镜像使用的是分层存储,容器也是如此。每一个容器运行时,是以镜像为基础层,在其上创建一个当前容器的存储层,我们可以称这个为容器运行时读写而准备的存储层为容器存储层。

    容器存储层的生存周期和容器一样,容器消亡时,容器存储层也随之消亡。因此,任何保存于容器存储层的信息都会随容器删除而丢失。

    按照 Docker 最佳实践的要求,容器不应该向其存储层内写入任何数据,容器存储层要保持无状态化。所有的文件写入操作,都应该使用 数据卷(Volume)、或者绑定宿主目录,在这些位置的读写会跳过容器存储层,直接对宿主(或网络存储)发生读写,其性能和稳定性更高。

    数据卷的生存周期独立于容器,容器消亡,数据卷不会消亡。因此,使用数据卷后,容器删除或者重新运行之后,数据却不会丢失。




    docker 镜像操作

    下载 CentOS 镜像

    docker pull centos:7
    

    查看centos7镜

    docker images
    

    docker image ls
    

    运行 centos7

    docker run -it xxxx bash
    
    • xxxx - 镜像名, 或 image id 的前几位
    • -it 这是两个参数,一个是 -i:交互式操作,一个是 -t 终端。我们这里打算进入 bash 执行一些命令并查看返回结果,因此我们需要交互式终端。
    • bash 放在镜像名后的是命令,这里我们希望有个交互式 Shell,因此用的是 bash。

    删除镜像

    • 501 镜像 id 前几位,一般三位以上,足够区分即可
    docker image rm 501
    
    • 删除指定仓库的镜像
    docker image rm centos
    

    镜像导出

    docker save mysql:5.7 node:8 | gzip > app.tar.gz  
    

    镜像导入

    docker load < apps.tar.gz  
    




    容器操作

    启动容器

    docker run -it centos:7 bash
    

    当利用 docker run 来创建容器时,Docker 在后台运行的标准操作包括:

    • 检查本地是否存在指定的镜像,不存在就从公有仓库下载
    • 利用镜像创建并启动一个容器
    • 分配一个文件系统,并在只读的镜像层外面挂载一层可读写层
    • 从宿主主机配置的网桥接口中桥接一个虚拟接口到容器中去
    • 从地址池配置一个 ip 地址给容器
    • 执行用户指定的应用程序
    • 执行完毕后容器被终止

    后台运行

    docker run -dit centos:7
    
    • -d 后台运行容器
    • 容器是否会长久运行,是和 docker run 指定的命令有关,和 -d 参数无关。

    查看后台运行的容器输出结果

    docker container logs 802
    

    查看容器

    docker container ls -a
    # 或
    docker ps -a
    
    • -a all, 全部

    终止容器

    docker container stop 802
    

    重新启动容器

    docker container restart 802
    

    进入容器

    在使用 -d 参数时,容器启动后会进入后台。

    某些时候需要进入容器进行操作,可以使用 docker exec 命令

    docker exec -it 802 bash
    

    删除容器

    docker container rm 802
    
    • 如果删除运行中的容器,需要添加 -f 参数

    清理所有终止状态容器

    docker container prune
    




    数据管理

    在这里插入图片描述

    在容器中管理数据主要有两种方式:

    • 数据卷(Volumes)
    • 挂载主机目录 (Bind mounts)

    数据卷

    数据卷 是一个可供一个或多个容器使用的特殊目录

    • 数据卷 可以在容器之间共享和重用
    • 对 数据卷 的修改会立马生效
    • 对 数据卷 的更新,不会影响镜像
    • 数据卷 默认会一直存在,即使容器被删除

    创建数据卷

    docker volume create my-vol
    

    查看所有数据卷

    docker volume ls
    

    查看指定 数据卷 的信息

    docker volume inspect my-vol
    

    查询的结果:

    [
        {
            "Driver": "local",
            "Labels": {},
            "Mountpoint": "/var/lib/docker/volumes/my-vol/_data",
            "Name": "my-vol",
            "Options": {},
            "Scope": "local"
        }
    ]
    

    启动挂载数据卷的容器

    docker run -it --mount source=my-vol,target=/webapp centos:7 bash
    
    # 或者:
    
    docker run -it -v my-vol:/webapp centos:7 bash
    
    • -v my-vol:/webapp 把数据卷 my-vol 挂载到容器的 /webapp 目录

    删除数据卷

    • 删除指定的数据卷,如果数据卷被容器使用则无法删除
    docker volume rm my-vol
    
    • 清理无主数据卷
    docker volume prune
    

    挂载主机目录

    docker run -it --mount type=bind,source=/usr/app,target=/opt/app centos:7 bash
    
    # 或
    
    docker run -it -v /usr/app:/opt/app centos:7 bash
    
    
    • -v 如果本地目录不存在 Docker 会自动为你创建一个文件夹
    • --mount 参数时如果本地目录不存在,Docker 会报错

    查看挂载目录信息

    docker inspect 91a
    

    显示结果:

    ...
    
    "Mounts": [
        {
            "Type": "bind",
            "Source": "/usr/app",
            "Destination": "/opt/app",
            "Mode": "",
            "RW": true,
            "Propagation": "rprivate"
        }
    ],
    
    ...
    
    




    网络

    自动分配映射端口

    docker run -d -P tomcat
    
    # 查看容器信息
    docker container ls -a
    

    显示结果:

    CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
    d03480b1a781        tomcat              "catalina.sh run"   3 minutes ago       Up 3 minutes        0.0.0.0:32768->8080/tcp   trusting_gagarin
    

    映射指定端口

    docker run -d -p 8080:8080 tomcat
    
    • 8080:8080 本机端口:容器端口

    映射多个端口

    docker run -d \
           -p 5000:5000 \
           -p 80:8080 tomcat
    

    映射指定端口(指定网卡)

    docker run -d -p 192.168.64.150:8080:8080 tomcat
    

    自动分配映射端口(指定网卡)

    docker run -d -p 192.168.64.150::8080 tomcat
    

    查看端口配置

    docker port 8af
    




    容器互联

    新建网络

    docker network create -d bridge my-net
    
    • -d driver,网络类型,默认 bridge,也可以是 overlay(Swarm mode)

    列出网络

    docker network ls
    

    查看网络信息

    docker inspect 67d
    

    连接容器

    docker run -it --name app1 --network my-net centos:7
    

    新开终端执行:

    docker run -it --name app2 --network my-net centos:7
    

    在两个终端中分别执行:

    ping app1
    
    ping app2
    

    显示如下:

    [root@35569c623c4c /]# ping app1
    PING app1 (172.18.0.2) 56(84) bytes of data.
    64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=1 ttl=64 time=0.577 ms
    64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=2 ttl=64 time=0.061 ms
    64 bytes from 35569c623c4c (172.18.0.2): icmp_seq=3 ttl=64 time=0.066 ms
    ......
    
    • 多个容器互联,推荐使用 Docker Compose




    Dockerfile

    准备

    • centos:7镜像
    • jdk压缩包 jdk-8u212-linux-x64.tar.gz
    • tomcat7压缩包 apache-tomcat-7.0.96.tar.gz

    Dockerfile文件

    #以centos7为基础,安装oracle jdk8和tomcat7
    FROM centos:7
    #ADD命令将压缩包传入镜像中的指定目录,并同时解压缩
    ADD jdk-8u212-linux-x64.tar.gz /opt/
    ADD apache-tomcat-7.0.96.tar.gz /usr/
    #为了方便,把文件夹名称改得简单一点
    RUN mv /usr/apache-tomcat-7.0.96 /usr/tomcat
    #设置环境变量
    ENV JAVA_HOME=/opt/jdk1.8.0_212 \
        CATALINA_HOME=/usr/tomcat \
        PATH=$PATH:/opt/jdk1.8.0_212/bin:/usr/tomcat/bin
    #暴露容器的8080端口
    EXPOSE 8080
    #设置启动容器时自动运行tomcat
    ENTRYPOINT /usr/tomcat/bin/startup.sh && tail -F /usr/tomcat/logs/catalina.out
    
    FROM centos:7
    ADD jdk-8u212-linux-x64.tar.gz /opt/
    ADD apache-tomcat-7.0.96.tar.gz /usr/
    RUN mv /usr/apache-tomcat-7.0.96 /usr/tomcat
    ENV JAVA_HOME=/opt/jdk1.8.0_212 \
        CATALINA_HOME=/usr/tomcat \
        PATH=$PATH:/opt/jdk1.8.0_212/bin:/usr/tomcat/bin
    EXPOSE 8080
    ENTRYPOINT /usr/tomcat/bin/startup.sh && tail -F /usr/tomcat/logs/catalina.out
    

    使用 Dockerfile 构建镜像

    docker build -t tomcat:7 .
    
    • 注意末尾的点,表示构建过程中从当前目录寻找文件

    启动容器

    准备存储目录

    • webapps目录,例如 /opt/webapps
    • logs目录,例如 /var/lib/tomcat-logs
    mkdir /opt/webapps
    mkdir /opt/webapps/ROOT
    mkdir /var/lib/tomcat-logs
    
    # 添加欢迎页
    cat <<EOF > /opt/webapps/ROOT/index.html
    <h1>Hello Docker!!!</h1>
    EOF
    

    启动容器,挂载目录

    docker run \
    -d \
    -p 8080:8080 \
    --name tomcat7 \
    -v /opt/webapps:/usr/tomcat/webapps \
    -v /var/lib/tomcat-logs:/usr/tomcat/logs \
    tomcat:7
    
    展开全文
  • 使用YUM 安装 docker

    万次阅读 2019-10-22 09:10:25
    第一步:查看系统内核(内核3.10以上 ) 如下图所示: 如果版本在Centos 7.0以上就可以了。 查看当前系统内核版本的命令如下: ...第二步:清理已经安装的docker(如果没有安装过,可以跳过此步) 清理...

    本文转载于https://blog.csdn.net/qq_26462567/article/details/102668640 

    第一步:查看系统内核(内核3.10以上 )

    如下图所示:
    在这里插入图片描述
    如果版本在Centos 7.0以上就可以了。
    查看当前系统内核版本的命令如下:

    uname -r 
    

    运行结果如下图:

    å¨è¿éæå¥å¾çæè¿°

    第二步:清理已经安装的docker(如果没有安装过,可以跳过此步)

    清理命令如下:

    yum remove docker \
                      docker-client \                  
    				  docker-client-latest \
                      docker-common \
                      docker-latest \
                      docker-latest-logrotate \
                      docker-logrotate \
                      docker-selinux \
                      docker-engine-selinux \
                      docker-engine
    
    

     

    第三步:安装Device Mapper工具

    安装命令如下:

    yum install -y yum-utils device-mapper-persistent-data lvm2
    

    第四步:配置docker的yum数据源

    配置yum数据源命令如下:

    yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    

    配置成功如下图:

    å¨è¿éæå¥å¾çæè¿°

    第五步:更新 yum缓存

    命令如下:

    yum makecache fast

     

    第六步:安装docker-ce(社区版)

    安装命令如下:

     yum -y install docker-ce

    第七步:启动docker

    启动命令如下:

    systemctl start docker

    开机启动

    systemctl    enable docker.service

    重启:

    systemctl restart docker

    启动容器开启启动 加入 --restart=always 

    no不自动重启容器. (默认value)

    on-failure 容器发生error而退出(容器退出状态不为0)重启容器

    unless-stopped 在容器已经stop掉或Docker stoped/restarted的时候才重启容器

    always 在容器已经stop掉或Docker stoped/restarted的时候才重启容器

    如果已经过运行的项目,使用update更新

    docker  update  --restart=always 容器名称

     

    启动后可以使用如下命令进行校验

     docker -v
    

    结果如下:

    å¨è¿éæå¥å¾çæè¿°

    展开全文
  • docker命令

    万次阅读 2017-12-06 11:42:36
    应用场景 docker使用的时候,有自己一套专业的...1. 镜像: # docker pull 镜像名 (下载镜像) # docker run -t -i 镜像名 /bin/bash (利用镜像创建一个容器,在其中运行bash) # docker images (查看镜像,repositor

    应用场景

    docker使用的时候,有自己一套专业的命令模式,其中有镜像,容器,仓库等等,其中各种命令用法比较容易混淆,这里粗略的整理一下。

    1. 镜像:

     # docker pull 镜像名    (下载镜像)
    
     # docker run -t -i 镜像名 /bin/bash        (利用镜像创建一个容器,在其中运行bash)
    
     # docker images (查看镜像,repository:仓库,TAG:镜像标签,标记同一仓库的不通镜像,ID:镜像唯一ID号)
    
     # docker tag 原仓库名:原版本名TAG ubuntu:latest  (为镜像添加新的标签TAG)
    
     # docker inspect 镜像名或镜像ID     (获取镜像的详细信息)
    
     # docker search 镜像名      (搜索镜像)
    
     # docker rmi 镜像名    (删除镜像,如果在镜像上层有容器运行,删除失败)
    
     # docker rmi -f 镜像名    (强制删除镜像)
    

    创建镜像有三种方式:

     # docker commit -m "add a new file" -a "Docker Newbee" 容器名 新的镜像名 (基于已有镜像的容器创建)
    
     # cat ubuntu-14.04-x86_64-minimal.tar.gz |docker import - ubuntu:14.04   (基于本地模板导入)
    
     # docker save -o ubuntu_14.04.tar ubuntu:14.04    (存出本地镜像到本地文件ubuntu:14.04)
    
     # docker load --input ubuntu_14.04.tar   (载入镜像)
    
     # docker push user/test:latest   (上传本地镜像到仓库 docker tag test:latest user/test:latest)
    

    2. 容器:

    启动容器有两种方式:一种是基于镜像新建一个容器并启动,一种是将终止状态的容器重新启动
    
     # docker create -it ubuntu:latest   (创建容器,create新建的容器处于禁止状态,docker start 容器名 来启动)
    
     # docker run ubuntu /bin/echo 'Hello World' (输出一个‘Hello World’,之后容器自动终止)
    
     # docker run -t -i ubuntu:14.04 /bin/bash     (启动一个bash终端,允许用户进行交互)
    
     # docker run -d ubuntu /bin/sh   (使docker容器在后台已守护状态运行)
    
     # docker stop/stop/restart 容器ID
    
     # docker run -idt 镜像名 ||  docker attach 容器名  (当多个窗口attach到同一个容器的时候,所有窗口会同步显示)
    
     # docker exec -ti 容器ID /bin/bash   (进入到刚刚创建的容器中)
    
     # docker rm 容器id或者容器名    (删除终止状态的容器  -f强制)
    
     # docker rm `docker ps -a -q`     (删除所有容器的命令)
    
     # docker export 容器id > test_for_run.tar    (导出容器到一个tar文件)
    
     # cat test_for_run.tar |docker import - test/ubuntu:v1.0  (导入文件,成为镜像)
    

    注:docker import 和docker load的区别:

    使用docker load命令来导入镜像存储文件到本地的镜像库;使用docker import命令来导入一个容器快照到本地镜像库。

    3. 仓库:

    集中存放镜像的地方,一个容器与之混淆的概念是注册服务器,实际上注册服务器是存放仓库的具体服务器,每个服务器上可以有多个仓库,每个仓库下面有多个镜像。
    
     # d1.dockerpoll.com/ubuntu   d1.dockerpoll.com是注册服务器地址,ubuntu是仓库名
    
     # docker run -d -p 5000:5000 registry   (自动下载并启动一个registry容器,创建本地的私有仓库)
    
     # curl 127.0.0.1:5000/v1/search   (访问私有仓库中所包含的镜像)
    
     # docker tag daocloud.io/library/mysql:latest 127.0.0.1:5000/test   (修改本地镜像的tag)
    
     # docker push 127.0.0.1:5000/test    (上传镜像到私有仓库)
    
     # docker pull 192.168.199.31:5000/test   (从私有仓库上pull到在使用的客户端)
    
     # tree /opt/data/registry/repositories/ (查看镜像的存储目录和文件  tree /tmp/registry/repositories/    yum -y install tree)
    
     # http://192.168.199.31:5000/v1/search   (浏览器访问私有仓库的镜像)
    

    4. 数据管理:

    用户杂使用docker的过程中,需要能查看容器内应用产生的数据,或者需要把容器内的数据进行备份,甚至多个容器之间进行数据的共享,这就涉及到容器的数据管理操作。管理数据的两种方式:数据卷,数据卷容器。

    1.在容器内创建数据卷,把本地的目录或文件挂载到容器内的数据卷中

    2.使用数据卷容器在容器和主机、容器和容器之间共享数据,并实现数据的备份和恢复。

    5. 数据卷:

     # sudo docker run -d -P --name web -v /webapp training/webapp python app.py (使用training/webapp镜像创建web容器,并创建一个数据卷挂载到容器的/webapp目录)
    
     # sudo docker run -d -P --name web -v /src/webapp:/opt/webapp:ro training/webapp python app.py (挂载主机的/src/webapp目录到容器的/opt/webapp目录做为数据卷)
    
     # sudo docekr run --rm -it -v ~/.bash_history:/.bash_history ubuntu /bin/bash (从主机挂载单个文件到容器中做为数据卷)
    
    数据卷容器:(其实就是一个普通的容器,专门提供数据卷供其他容器挂载使用)
    
     # docker run -it -v /dbdata --name dbdata ubuntu (创建一个数据卷容器dbdata,在其中创建一个数据卷挂载到/dbdata)
    
     # docker run -it --volumes-from dbdata --name db1 ubuntu   (容器db1和db2都挂载到了同一个数据卷到相同的/databata目录)
    
     # docker run -it --volumes-from dbdata --name db2 ubuntu
    

    6. 网络基础配置:

    docker提供了映射容器端口到宿主机和容器关联机制来为容器提供网络服务,使用端口映射机制来将容器内的应用服务提供给外部网络,通过容器互联让多个容器之间进行快捷的网络通信。

    容器与外部网络:
    
     # docker run -d -P training/webapp python app.py
    
    容器与容器间:
    
     # docker run -d --name db training/postgres
    
     # docker run -d -P --name web --link db:db training/webapp python app.py
    

    7. 使用dockerfile创建镜像

    包含四个部分:基础镜像信息,维护者信息,镜像操作指令和容器启动时执行指令
    
    FROM MAINTAINER RUN  CMD  EXPOSE  ENV ADD COPY ENTRYPOINT VOLUME USER WORKDIR ONBUILD
    
    创建镜像:
    
     # docker build -t build_repo/first_image /tmp/docker_builder/  (dockerfile所在路径/tmp/docker_builder,生成的镜像标签为build_repo/first_image)
    
     # docker run -ti -d -v /usr/local/src:/usr/local/src centos /bin/bash
    
     # docker run -d -ti –name tomcat01 docker.io/tomcat
    
     # docker run -ti docker.io/nginx /bin/bash
    
    
     # docker build -t="xubin/jweb" .       
    
    docker build -t xubin/jweb  .
    
    1,创建项目:https://github.com/changedi/mydocker
    
    2,编辑 Dockerfile:https://github.com/changedi/mydocker/blob/master/Dockerfile
    
    3,在本地项目中运行 docker build <image_name> .,build一个自定义名字的镜像
    
    4,启动这个镜像容器:docker run -d -p 80:80 <image_name>
    
    这样,这个镜像就好了,服务也起来了,后续可以通过docker ps来查看启动的镜像,通过docker stop来停止容器。
    
     # docker run -i -t -v /root/software/:/mnt/software/ 25c5298b1a36 /bin/bash
    
     # tar -zxf /mnt/software/jdk-7u67-linux-x64.tar.gz -C .
    
     # mv jdk1.7.0_67/ jdk/
    
     # tar -zxf /mnt/software/apache-tomcat-7.0.55.tar.gz -C .
    
     # mv apache-tomcat-7.0.55/ tomcat/
    
    首先,编辑.bashrc文件
    
     # vi ~/.bashrc
    
    然后,在该文件末尾添加如下配置:
    
     # export JAVA_HOME=/opt/jdk export PATH=$PATH:$JAVA_HOME
    
    最后,需要使用source命令,让环境变量生效:
    
     # source ~/.bashrc
    
    编写运行脚本
    
    我们需要编写一个运行脚本,当启动容器时,运行该脚本,启动 Tomcat,具体过程如下:
    
    首先,创建运行脚本:
    
     # vi /root/run.sh
    
    然后,编辑脚本内容如下:
    
     # !/bin/bash source ~/.bashrc sh /opt/tomcat/bin/catalina.sh run
    
    注意:这里必须先加载环境变量,然后使用 Tomcat 的运行脚本来启动 Tomcat 服务。
    
    最后,为运行脚本添加执行权限:
    
     # chmod u+x /root/run.sh
    
    退出容器
    
    当以上步骤全部完成后,可使用exit命令,退出容器。
    
    随后,可使用如下命令查看正在运行的容器:
    
     # docker ps
    
    使用以下命令,根据某个“容器 ID”来创建一个新的“镜像”:
    
     # docker commit 57c312bbaad1 huangyong/javaweb:0.1
    
     # docker run -d -p 58080:8080 --name javaweb huangyong/javaweb:0.1 /root/run.sh
    
    展开全文
  • Docker入门到实践

    万人学习 2014-11-29 13:50:07
    Docker的出现正好能帮助软件开发者开阔思路,尝试新的软件管理方法来解决这个问题。通过掌握Docker,开发人员便可享受先进的自动化运维理念和工具,无需运维人员介入即可顺利运行于各种运行环境。  《Docker技术...
  • Docker-常用命令-Study03

    万次阅读 2020-02-13 11:16:06
    1. 查看当前docker版本 docker version 2. 显示 Docker 系统信息,包括镜像和容器数 docker info 3. 查看帮助文档,类似于CentOS的Man命令 docker --help 二. 镜像命令 1. 查看本地主机上的镜像: #列出本地所有的...
  • Docker精选命令

    万次阅读 2019-01-19 19:19:11
    基本命令: dockerimages 显示所有的镜像 ...docker build -t tag:version Dockerfile_Directory 生成镜像(Eg:docker build -t runoob/ubuntu:v1 . ) docker tag source_images:version target_images:...
  • docker入门(利用docker部署web应用)

    万次阅读 多人点赞 2019-05-26 10:44:15
    前言:本课程是在慕课网上学习 第一个docker化的java应用 课程时所做的笔记,供本人复习之用 目录 第一章 什么是docker 1.1 docker的发展史 1.2 docker国内应用史 1.3 什么是Docker 第二章 了解docker 2.1 ...
  • docker服务启动,重启,关闭命令

    万次阅读 多人点赞 2018-05-26 18:16:50
    最近刚学习dockerdocker启动命令,docker重启命令,docker关闭命令启动 systemctl start docker守护进程重启 sudo systemctl daemon-reload重启docker服务 systemctl restart docker重启docker服务 sudo service ...
  • windows安装Dockerdocker-compose套装

    万次阅读 2020-06-07 02:38:36
    Docker Engine是一种开源容器化技术,用于构建和容器化您的应用程序,Docker的字面意思,船坞,我们日常开发中用到的Mysql、rabbitmq、redis都像是一个个集装箱,可以放到船坞里。并且,如果使用docker-compose配置...
  • Docker-Tomcat为何看不到访问界面?

    万次阅读 2020-02-15 11:45:21
    问题:源服务器未能找到目标资源的表示或者是不愿公开一个已经存在...Docker内的webapps目录 Tomcat7.0下的目录 怎么才看看到小猫呢 1.Docker内下载7.0版本的Tomcat 2.自己制作新的镜像(初学者可以尝试一下) ...
  • MacBook 安装 Dockerdocker-compose 套装

    万次阅读 2020-06-21 23:23:56
    MacBook 安装 Dockerdocker-compose 套装 下载地址 Docker for Mac 官方下载地址 安装 然后打开程序主界面,单击打开 点击小齿轮可以设置CPU与内存等 安装docker-compose 不好意思,Docker for Mac 自带 ...
  • 一文玩转 Docker

    万次阅读 2020-05-01 12:18:49
    Docker基本命令 镜像:(镜像,从认识上简单的来说,就是面向对象中的类,相当于一个模板。从本质上来说,镜像相当于一个文件系统。Docker 镜像是一个特殊的文件系统,除了提供容器运行时所需的程序、库、资源、配置...
  • docker-compose教程(安装,使用, 快速入门)

    万次阅读 多人点赞 2017-12-03 22:31:45
    教程基于ubuntu下最新的...Docker Compose是一个用来定义和运行复杂应用的Docker工具。一个使用Docker容器的应用,通常由多个容器组成。使用Docker Compose不再需要使用shell脚本来启动容器。 Compose 通过一个配...
  • Linux安装Docker(CentOS 8) 1.操作系统 查看版本 lsb_release -a 这里是 [root@aliyun ~]# lsb_release -a LSB Version: :core-4.1-amd64:core-4.1-noarch Distributor ID: CentOS Description: CentOS Linux ...
  • 本文参考keep-go-on博文 第一步:下载mysql镜像镜像 docker pull mysql ...docker run --name dockermysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=mysqlpassword -d mysql --name 是镜像的别名 -p 将3306映射...
  • 与sgy一起开启你的Docker之路 关键词: Docker; mac; Docker中使用gdb无法进入断点,无法调试; 写在前面 这篇博客适合谁? 对于Docker并不了解,只是有一点模糊的感觉,觉得Docker可以当成虚拟机用之类的 只是...
  • Docker---(2)docker pull 下来的镜像存储在哪里

    万次阅读 多人点赞 2018-01-10 09:20:54
    docker pull xxx,就可以把想要的镜像拉下来直接使用,但是pull下来的镜像存储在哪里呢?这里做下记录: 此处docker 版本为:Docker version 1.13.1 1. 进入docker目录,如下: root@iZuf6axmuekh1n14dwcufmZ:/# cd ...
  • docker安装fastdfs集群

    万次阅读 2020-04-23 16:31:12
    dockerhub上搜索fastdfs 我选择了使用最多的星星最多的镜像 season/fastdfs 拉取镜像 docker pull season/fastdfs 创建数据卷 docker volume create tracker_data docker volume create storage_data ...
  • 初识Docker

    万次阅读 多人点赞 2018-05-07 10:38:02
    Ubuntu Docker 安装 CentOS Docker 安装 Windows Docker 安装 MacOS Docker 安装 这里我的电脑是mac,采用brew安装,安装完毕记得更换国内的docker镜像源哦. 安装完毕,就开始使用,一探docker的神秘了. 开始之前...
  • docker安装node运行网易云音乐api

    万次阅读 2020-05-10 04:31:20
    docker pull node 创建数据卷 docker volume create node 创建文件夹 mkdir -p /var/lib/docker/volumes/node/_data/MusicApi api服务器的github地址:https://github.com/Binaryify/NeteaseCloudMusicApi ...
  • docker-compose详解

    万次阅读 多人点赞 2019-02-18 11:06:19
    1 安装: 官方: curl -L ...chmod +x /usr/local/bin/docker-compose 或者使用包管理工具:...
  • docker搭建redis集群

    万次阅读 2020-04-19 05:02:36
    下载redis镜像 ...docker tag docker.io/yyyyttttwwww/redis redis 删除原先的镜像标签 docker rmi docker.io/yyyyttttwwww/redis 启动6个节点的redis容器 注意网络用的是net1 docker run ...
  • Docker常用命令

    万次阅读 2019-11-12 19:04:45
    官网的命令行接口文档:...docker run +选项 官网:https://docs.docker.com/engine/reference/commandline/run/ docker run -it 镜像id 启动镜像 结果如下 ctrl + p + q 可以...
  • docker启动zookeeper服务器

    万次阅读 2020-05-06 15:17:27
    docker_hub上搜索zookeeper 我选择了第一个,也就是官方的镜像 网易云镜像地址,找一个合适的zookeeper镜像下载下来,并且参考下面的启动zookeeper的命令启动容器 下载镜像 docker pull zookeeper 启动容器 ...
  • docker更新容器使其自启动

    万次阅读 2020-06-17 13:36:16
    使用docker update命令进行更新即可 docker update --restart=always #容器id或别名 docker update --配置=值 这种格式 官网地址:https://docs.docker.com/engine/reference/commandline/update/
  • Docker——入门实战

    万次阅读 多人点赞 2018-07-14 15:35:24
    Docker 简介 Docker是一种新兴的虚拟化技术,能够一定程度上的代替传统虚拟机。不过,Docker 跟传统的虚拟化方式相比具有众多的优势。我也将Docker类比于Python虚拟环境,可以有效的配置各个版本的开发环境,...
  • docker-集群 什么是docker集群 什么是集群 1、先生活中集群 2、再软件中集群 3、最后总结 总结:不同服务实例,来共同提供服务的一组集合就是集群 集群类型 1、先看两个集群例子:nginx集群,redis集群 2、然后总结 ...

空空如也

1 2 3 4 5 ... 20
收藏数 355,951
精华内容 142,380
关键字:

docker