精华内容
下载资源
问答
  • Docker技术

    2018-09-26 09:07:54
    Docker非常好的学习资料,一整套资源的,可以慢慢学习,深入了解。
  • Docker技术入门教程 * 什么是Docker 镜像 容器 仓库 数据卷 网络 练习搭建第一个Docker镜像 业务镜像&代码 * 什么是Docker Docker 是一个开源的应用容器引擎让开发者可以打包应用以及依赖包到一个可移植的容器中然后...
  • docker入门与进阶的书籍,请查收 资源非超好docker入门与进阶的书籍,请查收 资源非超好
  • Docker技术分享

    2018-08-06 17:12:31
    docker技术应用,链接地址:https://blog.csdn.net/kjddd/article/details/81456945
  • docker技术介绍

    2018-06-06 13:41:07
    docker技术介绍,对于没有相关认知的人可以下载一下稍微了解了解,对docker会有一个比较清晰的认识
  • Docker技术入门与实践

    2018-12-03 11:41:47
    中国首部Docker著作,一线Docker先驱实战经验结晶。结合企业生产环境,深入浅出剖析Docker的核心概念,应用技巧,实现原理以及生态环境,为解决各类问题提供了有价值的参考。
  • docker技术pdf文档

    2019-01-26 00:30:43
    该压缩文件包含Docker 源码分析、Docker+容器与容器云(第2版)、Docker技术入门与实战、Docker实战
  • 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安装教程(Ubuntu) 本人腾讯云服务器安装成功

    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
    # 以带密码的方式启动, 密码设置为root
    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  --requirepass "root"
    # 或者不适用上面的容器卷, 使用docker 默认配置, 并设置自动重启
    docker run --name redis -p 6379:6379 -d --restart=always redis:latest redis-server --appendonly yes --requirepass "root"
    
    # 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技术与实践 docker入门教程 适合docker初学者。
  • DockerDocker技术简介Docker的应用场景Docker 的组成 Docker技术简介 Docker 如日中天,这不是单纯的炒的概念,Docker的确解决了开发和运费的痛点,比如版本的搬迁,从测试环境搬迁到预发、生产环境,在企业开发与...

    Docker技术简介

    在这里插入图片描述

    Docker 如日中天,这不是单纯的炒的概念,Docker的确解决了开发和运费的痛点,比如版本的搬迁,从测试环境搬迁到预发、生产环境,在企业开发与测试中,得到了非常广泛的应用。

    • Docker 是一个开放源码的软件项目,基于GO语言
    • Docker 可以让开发打包他们的应用以及依赖包到一个轻量级、可移植的容器中
    • Docker 打包好容器,可以发布到任何流行的 Linux 机器上,也可以实现虚拟化
    • 容器是完全使用沙箱机制,互相之间不会有任何接口
    • Docker 容器性能开销极低,这个才是关键
    • Docker 使用客户端-服务器(C/S)架构模式,使用远程API来管理和创建Docker容器

    Docker的应用场景

    1. Web应用自动化打包和发布
    2. 自动化测试和持续集成、发布
    3. 在服务器环境中部署和调整数据库或其他的后台应用
    4. 使用Docker可以实现开发环境、测试环境、生成环境的一致性

    在这里插入图片描述
    Docker 借鉴了标准的集装箱的概念。标准的集装箱将货物运往世界各地,Docker 将这个模型运行到自己的设计中。唯一不同的是: 集装箱是运输货物,Docker是运输软件。

    Docker和传统的VM的区别

    在这里插入图片描述
    传统的虚拟机基于安装操作系统上的虚拟机管理系统,如 VirtualBox 和 VMWare等,创建虚拟机,在虚拟机上安装从操作系统,在从操作系统中安装部署各种应用。

    在这里插入图片描述
    Docker容器是在操作系统层面上实现虚拟化,直接复用本地主机的操作系统,而传统虚拟机则是在硬件层面实现虚拟化。

    docker 与传统的VM对比:

    1. 启动速度:vm 一般几十秒或者几分钟,docker几秒或者毫秒
    2. 大小:vm 一般几G,docker只有几兆

    Docker 的组成

    在这里插入图片描述
    Docker 需要分为三部分: 仓库镜像 容器

    名称说明
    Docker镜像Docker 镜像是用于创建Docker容器的模板。镜像是基于联合文件系统的一种层式结构,由一系列指令一步一步构建出来。
    Docker容器容器是独立运行的一个或多个应用。镜像相当于类,容易相当于类的实例
    Docker客户端Docker客户端通过命令行或者其他工具使用Docker API与Docker的守护进程通信
    Docker主机一个物理或者虚拟的机器用于执行Docker守护进程和容器
    Docker守护进程是Docker服务器端进程,负责支撑Docker容器的运行以及镜像的管理
    Docker仓库Docker仓库用来保存镜像,可以理解为代码控制中的代码仓库。Docker Hub提供了庞大的镜像集合供使用,用户也可以将自己本地的镜像推送到Docker仓库供其他人下载

    docker进程相关操作

    查看docker版本

    docker -v
    

    查看docker命令

    docker --help
    

    查看docker服务端与客户端版本详情

    docker version
    

    启动docker

    systemctl start docker
    

    关闭docker

    systemctl stop docker
    

    重启docker

    systemctl restart docker
    

    查看docker运行状态

    systemctl status docker
    

    关闭防火墙

    systemctl stop firewalld
    

    docker加速

    默认情况下,docker下载镜像是从官网下载,下载速度特别慢,我们可以使用阿里云加速器可已提升获取Docker官网镜像的速度。

    1. 执行目录创建文件(如已存在请忽略此步)
    touch /ect/docker/deamon.json
    
    1. 修改文件内容为
       {
         "registry-mirrors": ["https://v2c6fjn8.mirror.aliyuncs.com"]
       }
    

    注意:此网址是从阿里云控制台复制过来的,每个登录用户都不一样。当然用这个也是可以的。

    1. 重启docker服务
    systemctl restart docker
    

    镜像操作

    查看本地镜像

    docker images
    

    搜索镜像,这里以安装tomcat为例

    [root@iZbp18425116ezmjdmbdgeZ ~]# docker search tomcat
    NAME                          DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
    tomcat                        Apache Tomcat is an open source implementati…   3193      [OK]       
    tomee                         Apache TomEE is an all-Apache Java EE certif…   94        [OK]       
    dordoka/tomcat                Ubuntu 14.04, Oracle JDK 8 and Tomcat 8 base…   58                   [OK]
    kubeguide/tomcat-app          Tomcat image for Chapter 1                      31                   
    consol/tomcat-7.0             Tomcat 7.0.57, 8080, "admin/admin"              18                   [OK]
    cloudesire/tomcat             Tomcat server, 6/7/8                            15                   [OK]
    aallam/tomcat-mysql           Debian, Oracle JDK, Tomcat & MySQL              13                   [OK]
    arm32v7/tomcat                Apache Tomcat is an open source implementati…   11                   
    rightctrl/tomcat              CentOS , Oracle Java, tomcat application ssl…   7                    [OK]
    maluuba/tomcat7-java8         Tomcat7 with java8.                             6                    
    arm64v8/tomcat                Apache Tomcat is an open source implementati…   6                    
    unidata/tomcat-docker         Security-hardened Tomcat Docker container.      5                    [OK]
    jelastic/tomcat               An image of the Tomcat Java application serv…   3                    
    amd64/tomcat                  Apache Tomcat is an open source implementati…   3                    
    cfje/tomcat-resource          Tomcat Concourse Resource                       2                    
    fabric8/tomcat-8              Fabric8 Tomcat 8 Image                          2                    [OK]
    oobsri/tomcat8                Testing CI Jobs with different names.           2                    
    camptocamp/tomcat-logback     Docker image for tomcat with logback integra…   1                    [OK]
    picoded/tomcat7               tomcat7 with jre8 and MANAGER_USER / MANAGER…   1                    [OK]
    99taxis/tomcat7               Tomcat7                                         1                    [OK]
    chenyufeng/tomcat-centos      tomcat基于centos6的镜像                              1                    [OK]
    ppc64le/tomcat                Apache Tomcat is an open source implementati…   1                    
    softwareplant/tomcat          Tomcat images for jira-cloud testing            0                    [OK]
    secoresearch/tomcat-varnish   Tomcat and Varnish 5.0                          0                    [OK]
    s390x/tomcat                  Apache Tomcat is an open source implementati…   0                    
    [root@iZbp18425116ezmjdmbdgeZ ~]# 
    
    

    找到所有的镜像,拉取镜像

    docker pull 镜像ID  #最新版本 如: docker pull tomcat
    docker pull tomcat:7 # 指定版本
    

    删除镜像

    docker rmi 容器名称
    

    本地以有镜像,创建容器

    docker create --name=容器名称 镜像名称
    
    示例:
    [root@iZbp18425116ezmjdmbdgeZ ~]# docker create --name=myTomcat tomcat
    629104460e3fe485649e5784ec0c34f4dcc2277115937a54be00b968dc646510
    

    查看容器

    docker ps # 查看正在运行的容易
    docker ps -a # 查看所有容器
    

    运行容器

    docker start myTomcat # start 后端可以跟容易id (前2-3位) 或者容器名称
    

    停止容器

    docker stop myTomcat
    

    删除没有运行的容器

    docker rm 容器id或者名称
    

    删除正在运行的容器

    docker -rm -f 容器id或者名称
    

    删除所有容器

    # 先停止所有的容器
    docker stop $(docker ps -a -q)
    
    # 删除
    docker rm $(docker ps -a -q)
    

    运行容器的相关操作

    查看docker run 命令 ,创建并且启动容器

    docker run --help
    docker run 后面的参数
    	-i # 运行容器
    	-t # 容器启动后,进入命令行
    	-v # 目录映射 --挂载
    	-d # 守护进程 --后台运行
    	-p # 端口映射 如容器里面有tomcat,你本地的windows想访问:
    	# docker tomcat 端口号是8080,需要在虚拟机映射一个端口9099
    	# windows才可以访问 http://虚拟机ip:9099
    

    创建容器,并且进入命令行

    docker run -it --name=myTomcat2 tomcat /bin/bash
    

    退出

    exit
    

    退出之后,重新进入容器

    # 创建一个守护的容器
    docker run -id --name=myTomcat2 tomcat
    # 进入
    docker exec -it myTomcat2 /bin/bash
    

    宿主机与docker容器的文件传递

    1、在宿主机上创建一个文件
    touch test.txt
    
    2、把文件复制到容器里面去
    docker cp test.txt myTomcat2:/
    
    3、进入跟目标
    cd /
    

    从容器中的文件copy到宿主机中

    touch abc.txt
    
    # 退出容器
    exit
    
    # 将容器中的文件复制到宿主机
    docker cp myTomcat2:abc.txt /root
    

    访问tomcat

    # 启动并作为守护进程
    # -p 宿主机的端口: 容器里应用的端口8080
    # war 挂载宿主机 -v 宿主机的路径: 容器路径
    docker run -di --name --myTomcat -p 8080:8080 -v /usr/local/tomcat/webapps:/usr/local/tomcat/webapps tomcat
    
    http://虚拟机ip:9999
     
     # 把war包放到宿主机的挂载目录中,直接刷新浏览器就出现项目的页面
    # 微服务 k8s 容器式的性能测试
    

    镜像备份

    docker save -o tomcat.tar 镜像名称
    
    # 把tomcat.tar 放到其他电脑,其他人变成镜像
    docker load -i tomcat.tar
    

    容器之间的关联

    docker run -di --name=tomcat2 -p 8080:8080 --link mysql
    
    展开全文
  • Docker技术的介绍

    2015-09-28 13:11:16
    Docker技术的介绍及Docker和VM的对比,
  • Docker技术基础讲解PPT

    2020-07-09 20:28:36
    提供了Docker技术的讲解PPT和对应脑图,可以帮助有需要的友理清思维逻辑,循序掌握Docker的基础。
  • docker技术介绍( 一)

    2016-04-27 16:30:14
    一、Docker案例介绍 二、Docker概念介绍 三、Docker与虚拟机对比 四、Docker应用场景 五、Docker的实用性 六、Docker基本原理 七、Docker基本命令介绍 八、Docker调度工具介绍 九、Docker最佳实践
  • image 下载地址...... ...本书从Docker基本原理开始,深入浅出地讲解Docker的构建与操作,内容系统全面,可帮助开发人员、运维人员快速部署Docker应用。本书分为四大部分:基础入门、实战案例、进...
    4624570-6c554713ff0be004
    image

    下载地址......

    好书推荐、视频分享,公众号读书ReadBook与您一起进步,回复关键字 41219直接获取下载链接

    内容简介 · · · · · ·

    本书从Docker基本原理开始,深入浅出地讲解Docker的构建与操作,内容系统全面,可帮助开发人员、运维人员快速部署Docker应用。本书分为四大部分:基础入门、实战案例、进阶技能、开源项目,第一部分(第1~8章)介绍Docker与虚拟化技术的基本概念,包括安装、镜像、容器、仓库、数据卷,端口映射等;第二部分(第9~16章)通过案例介绍Docker的应用方法,包括与各种操作系统平台、SSH服务的镜像、Web服务器与应用、数据库的应用、各类编程语言的接口、容器云等,还介绍了作者在容器实战中的思考与经验总结;第三部分(第17~21章)是一些进阶技能,如Docker核心技术实现原理、安全、高级网络配置、libernetwork插件化网络功能等;第四部分(第22~28章)介绍与容器开发相关的开源项目,包括Etcd、Docker Machine、Docker Compose、Docker Swarm、Mesos、Kubernetes等。

    第2版参照Docker技术的*新进展对全书内容进行了修订,并增加了第四部分专门介绍与容器相关的知名开源项目,利用好这些优秀的开源平台,可以更好地在生产实践中受益。

    作者简介 · · · · · ·

    杨保华:博士,毕业于清华大学,现为 IBM 资深研究员。主要负责核心系统方案的架构设计和研发,包括云计算、大数据、金融科技等领域。他热爱开源文化,是容器、软件定义网络、区块链等开源技术的早期推广者,曾为 OpenStack、HyperLedger 等开源项目作出了贡献。个人主页为 https://yeasy.github.com

    戴王剑:资深架构师,多年来一直从事系统平台、计算机网络、服务器架构设计,负责过多个省级项目的架构设计。热衷于开源事业,积极推动开源技术在生产实践中的应用。

    曹亚仑:阿里云高级系统工程师(花名法喜),上云架构师,擅长云产品运维与云平台技术保障,对PaaS、IaaS层架构设计与实践有较丰富的实战经验。同时也是DevOps实践者与全栈开发者。微信allengaller,个人主页为allengaller.github.io。

    目录 · · · · · ·

    第2版前言
    第1版前言
    第一部分 基础入门
    第1章 初识容器与Docker 3
    1.1 什么是Docker 3
    1.2 为什么要使用Docker 5
    1.3 Docker与虚拟化 7
    1.4 本章小结 9
    第2章 核心概念与安装配置 10
    2.1 核心概念 10
    2.2 安装Docker 11
    2.2.1 Ubuntu环境下安装Docker 12
    2.2.2 CentOS环境下安装Docker 14
    2.2.3 通过脚本安装 14
    2.2.4 Mac OS环境下安装Docker 15
    2.2.5 Windows环境下安装Docker 20
    2.3 配置Docker服务 21
    2.4 推荐实践环境 22
    2.5 本章小结 22
    第3章 使用Docker镜像 23
    3.1 获取镜像 23
    3.2 查看镜像信息 25
    3.3 搜寻镜像 28
    3.4 删除镜像 29
    3.5 创建镜像 31
    3.6 存出和载入镜像 32
    3.7 上传镜像 33
    3.8 本章小结 33
    第4章 操作Docker容器 34
    4.1 创建容器 34
    4.2 终止容器 39
    4.3 进入容器 40
    4.4 删除容器 42
    4.5 导入和导出容器 42
    4.6 本章小结 44
    第5章 访问Docker仓库 45
    5.1 Docker Hub公共镜像市场 45
    5.2 时速云镜像市场 47
    5.3 搭建本地私有仓库 48
    5.4 本章小结 50
    第6章 Docker数据管理 51
    6.1 数据卷 51
    6.2 数据卷容器 52
    6.3 利用数据卷容器来迁移数据 53
    6.4 本章小结 54
    第7章 端口映射与容器互联 55
    7.1 端口映射实现访问容器 55
    7.2 互联机制实现便捷互访 57
    7.3 本章小结 59
    第8章 使用Dockerfile创建镜像 60
    8.1 基本结构 60
    8.2 指令说明 62
    8.3 创建镜像 67
    8.4 使用.dockerignore文件 67
    8.5 最佳实践 67
    8.6 本章小结 68
    第二部分 实战案例
    第9章 操作系统 71
    9.1 BusyBox 71
    9.2 Alpine 72
    9.3 Debian/Ubuntu 74
    9.4 CentOS/Fedora 76
    9.5 本章小结 77
    第10章 为镜像添加SSH服务 78
    10.1 基于commit命令创建 78
    10.2 使用Dockerfile创建 80
    10.3 本章小结 82
    第11章 Web服务与应用 83
    11.1 Apache 83
    11.2 Nginx 87
    11.3 Tomcat 88
    11.4 Jetty 92
    11.5 LAMP 93
    11.6 CMS 94
    11.6.1 WordPress 94
    11.6.2 Ghost 96
    11.7 持续开发与管理 96
    11.7.1 Jenkins 97
    11.7.2 Gitlab 98
    11.8 本章小结 99
    第12章 数据库应用 100
    12.1 MySQL 100
    12.2 MongoDB 102
    12.2.1 使用官方镜像 102
    12.2.2 使用自定义Dockerfile 104
    12.3 Redis 106
    12.4 Memcached 108
    12.5 CouchDB 108
    12.6 Cassandra 109
    12.7 本章小结 110
    第13章 分布式处理与大数据平台 111
    13.1 RabbitMQ 111
    13.2 Celery 113
    13.3 Hadoop 114
    13.4 Spark 115
    13.4.1 使用官方镜像 116
    13.4.2 验证 116
    13.5 Storm 117
    13.6 Elasticsearch 119
    13.7 本章小结 120
    第14章 编程开发 121
    14.1 C/C++ 121
    14.1.1 GCC 121
    14.1.2 LLVM 122
    14.1.3 Clang 122
    14.2 Java 123
    14.3 Python 124
    14.3.1 使用官方的Python镜像 124
    14.3.2 使用PyPy 124
    14.4 JavaScript 125
    14.5 Go 127
    14.5.1 搭建并运行Go容器 127
    14.5.2 Beego 130
    14.5.3 Gogs:基于Go的Git服务 130
    14.6 PHP 130
    14.7 Ruby 132
    14.7.1 使用Ruby官方镜像 132
    14.7.2 JRuby 133
    14.7.3 Ruby on Rails 134
    14.8 Perl 135
    14.9 R 136
    14.10 Erlang 138
    14.11 本章小结 140
    第15章 容器与云服务 141
    15.1 公有云容器服务 141
    15.1.1 AWS 141
    15.1.2 Google Cloud Platform 142
    15.1.3 Azure 143
    15.1.4 腾讯云 144
    15.1.5 阿里云 144
    15.1.6 华为云 144
    15.1.7 UCloud 145
    15.2 容器云服务 145
    15.2.1 基本要素与关键特性 146
    15.2.2 网易蜂巢 146
    15.2.3 时速云 147
    15.2.4 Daocloud 148
    15.2.5 灵雀云 148
    15.2.6 数人云 149
    15.3 阿里云容器服务 150
    15.4 时速云容器平台 151
    15.5 本章小结 153
    第16章 容器实战思考 154
    16.1 Docker为什么会成功 154
    16.2 研发人员该如何看容器 155
    16.3 容器化开发模式 156
    16.4 容器与生产环境 158
    16.5 本章小结 160
    第三部分 进阶技能
    第17章 Docker核心实现技术 163
    17.1 基本架构 163
    17.2 命名空间 165
    17.3 控制组 167
    17.4 联合文件系统 169
    17.5 Linux网络虚拟化 171
    17.6 本章小结 174
    第18章 配置私有仓库 175
    18.1 安装Docker Registry 175
    18.2 配置TLS证书 177
    18.3 管理访问权限 178
    18.4 配置Registry 181
    18.4.1 示例配置 181
    18.4.2 选项 183
    18.5 批量管理镜像 188
    18.6 使用通知系统 190
    18.6.1 相关配置 190
    18.6.2 Notif?ication的使用场景 192
    18.7 本章小结 193
    第19章 安全防护与配置 194
    19.1 命名空间隔离的安全 194
    19.2 控制组资源控制的安全 195
    19.3 内核能力机制 195
    19.4 Docker服务端的防护 197
    19.5 更多安全特性的使用 197
    19.6 使用第三方检测工具 198
    19.6.1 Docker Bench 198
    19.6.2 clair 199
    19.7 本章小结 199
    第20章 高级网络功能 201
    20.1 网络启动与配置参数 201
    20.2 配置容器DNS和主机名 203
    20.3 容器访问控制 204
    20.4 映射容器端口到宿主主机的实现 206
    20.5 配置docker0网桥 207
    20.6 自定义网桥 208
    20.7 使用OpenvSwitch网桥 209
    20.8 创建一个点到点连接 211
    20.9 本章小结 212
    第21章 libnetwork插件化网络功能 213
    21.1 容器网络模型 213
    21.2 Docker网络相关命令 215
    21.3 构建跨主机容器网络 216
    21.4 本章小结 219
    第四部分 开源项目
    第22章 Etcd——高可用的键值数据库 223
    22.1 简介 223
    22.2 安装和使用Etcd 224
    22.3 使用etcdctl客户端 228
    22.3.1 数据类操作 230
    22.3.2 非数据类操作 233
    22.4 Etcd集群管理 236
    22.4.1 构建集群 236
    22.4.2 集群参数配置 238
    22.5 本章小结 240
    第23章 Docker三剑客之Docker Machine 241
    23.1 简介 241
    23.2 安装Machine 241
    23.3 使用Machine 243
    23.4 Machine命令 244
    23.5 本章小结 247
    第24章 Docker三剑客之Docker Compose 248
    24.1 简介 248
    24.2 安装与卸载 249
    24.3 Compose命令说明 252
    24.4 Compose环境变量 257
    24.5 Compose模板文件 257
    24.6 Compose应用案例一:Web负载均衡 266
    24.7 Compose应用案例二:大数据Spark集群 271
    24.8 本章小结 273
    第25章 Docker三剑客之Docker Swarm 274
    25.1 简介 274
    25.2 安装Swarm 275
    25.3 使用Swarm 277
    25.4 使用其他服务发现后端 281
    25.5 Swarm中的调度器 282
    25.6 Swarm中的过滤器 284
    25.7 本章小结 286
    第26章 Mesos——优秀的集群资源调度平台 287
    26.1 简介 287
    26.2 Mesos安装与使用 288
    26.3 原理与架构 296
    26.3.1 架构 296
    26.3.2 基本单元 297
    26.3.3 调度 297
    26.3.4 高可用性 298
    26.4 Mesos配置项解析 299
    26.4.1 通用项 299
    26.4.2 master专属项 299
    26.4.3 slave专属项 301
    26.5 日志与监控 304
    26.6 常见应用框架 306
    26.7 本章小结 307
    第27章 Kubernetes——生产级容器集群平台 308
    27.1 简介 308
    27.2 核心概念 309
    27.2.1 集群组件 311
    27.2.2 资源抽象 312
    27.2.3 辅助概念 315
    27.3 快速体验 318
    27.4 安装部署 322
    27.5 重要组件 331
    27.5.1 Etcd 332
    27.5.2 kube-apiserver 332
    27.5.3 kube-scheduler 333
    27.5.4 kube-controller-manager 333
    27.5.5 kubelet 334
    27.5.6 kube-proxy 335
    27.6 使用kubectl 337
    27.6.1 获取kubectl 337
    27.6.2 命令格式 337
    27.6.3 全局参数 338
    27.6.4 子命令 339
    27.7 网络设计 351
    27.8 本章小结 353
    第28章 其他相关项目 354
    28.1 平台即服务方案 354
    28.1.1 Deis 354
    28.1.2 Flynn 355
    28.2 持续集成平台Drone 355
    28.3 容器管理 357
    28.3.1 Citadel 357
    28.3.2 Shipyard 358
    28.3.3 DockerUI 358
    28.3.4 Panamax 358
    28.3.5 Seagull 359
    28.3.6 Dockerboard 361
    28.4 编程开发 362
    28.5 网络支持 363
    28.5.1 pipework 363
    28.5.2 Flannel 364
    28.5.3 Weave Net 364
    28.5.4 Calico 365
    28.6 日志处理 366
    28.6.1 Docker-Fluentd 366
    28.6.2 Logspout 367
    28.6.3 Sematext-agent-docker 368
    28.7 服务代理工具 368
    28.7.1 Traefik 369
    28.7.2 Muguet 370
    28.7.3 nginx-proxy 370
    28.8 标准与规范 372
    28.9 其他项目 375
    28.9.1 CoreOS 375
    28.9.2 OpenStack支持 375
    28.9.3 dockerize 376
    28.9.4 Unikernel 378
    28.9.5 容器化的虚拟机 378
    28.10 本章小结 379
    附录
    附录A 常见问题总结 382
    附录B Docker命令查询 388
    附录C 参考资源链接 393

    下载地址......

    好书推荐、视频分享,公众号读书ReadBook与您一起进步,回复关键字 41219直接获取下载链接

    Python大礼包请回复 “python0426”即可获取

    展开全文
  • 以下全文内容出自书目:《 Docker 技术入门与实战 》 1. Docker 镜像:一个只读模板,是创建容器的基础 。 2. Docker 容器:从镜像创建运行的实例 ,可以看作是一个简易版本的 Linux 系统环境 。 3. Docker ...

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到教程。

    PS :个人所有读书笔记只记录个人想要的内容,很可能原书大量内容没有纳入笔记中... ... 

    以下全文内容出自书目:《 Docker 技术入门与实战 》

    1. Docker 镜像:一个只读模板,是创建容器的基础 。

    2. Docker 容器:从镜像创建运行的实例 ,可以看作是一个简易版本的 Linux 系统环境 。

    3. Docker 仓库:集中存放镜像文件的场所 。

    4. Docker 目前只能运行在 64 位平台上,并要求内核版本不低于 3.10 (可用 uname -a 或者 cat /proc/version 查看自己内核详情)。

    5. Ubuntu 安装 Docker :apt-get install -y docker-engine  ( 见书P12 ) 。

    6. CentOS 安装 Docker :

    7. docker 服务开启/重启方式:systemctl start docker.service   、 service docker restart  。

    8. 查看 docker 版本信息:  docker version 。

    9. 查看镜像 : docker images 

        -a : 列出所有镜像。
    
        --digests=true|false :列出镜像数字摘要,默认为否。
    
        -f ,--filter=[] : 过滤列出镜像,如 dangling=true 只显示没有被使用的镜像 。
    
        --format="TEMPLATE":控制输出格式,如 ID 代表 ID 信息, .Repository 代表仓库信息 。
    
        --no-trunc=true|false : 是否截断输出结果中太长的部分 。
    
        -q ,--quiet=true|false : 仅输出 ID ,默认为否 。

    --------------------------------------  以下更新于2018.7.9  --------------------------------------

    10.  查看镜像创建过程: docker history  镜像名。

    11.  删除镜像: docker rmi 镜像名、镜像ID(当镜像只剩下一个 tag 时会彻底删除镜像,命令 docker images 可查看镜像)。

    12. 查看所有容器 : docker ps -a 。

    13. 镜像导出到本地文件:docker save -o xxx.tar 原镜像名。

    14. 镜像导入: docker load <  镜像名 或 docker load --input  镜像名,如 docker load < xxx.tar 。

         ( A导出 + B导入 + run 可以把一个工程从服务器 A 拷贝到服务器 B 并部署运行,见第 20、21 点 。) 

    15. 上传镜像到仓库 :docker push ,默认是上传到 Docker Hub 官方仓库 。

    16. 创建容器 : docker  create 镜像名,参数如下:  (另一种创建方式见第 28 点。)

        -d:后台运行。
    
        -i:保持标准输入打开,默认为 false 。
    
        --net="bridge" :指定容器网络模式 。
    
        --rm=true :容器退出后自动删除 ( 不能和 -d 同时使用 )。
    
        -t: 分配一个伪终端,默认为 false 。
    
        -v | --volume=本机目录 : 容器目录 : 挂载主机上文件卷到容器 。
    
        --volume-from=[ ]  : 从其它容器挂载卷 。
    
        -w | --workdir=" "  : 容器的默认工作目录 。 
    
        -e | --env=[ ] :指定容器环境变量 。
    
        -h | --hostname=" "  : 指定容器内的主机名 。 
    
        --link=[ < name or id >:alias ] :链接到其它容器 。 
    
        --name=" " :指定容器名 。 

    17. 终止运行中的容器 : docker stop 。

    18. 进入容器以便可以执行任意命令: docker exec 容器名、id,如:docker exec -it 镜像id /bin/bash 。参数如下:

        --privileged=true :给执行命令以最高权限,默认为 false 。
    
        -u | --user=" " :执行命令的用户名或 ID 。
    
        -i : 开启标准输入 。 
    
        -t:分配伪终端,默认为 false 。

    19 . 删除容器:docker rm ,参数如下:

        -f: 强行终止并删除运行中的容器 。
    
        -l | --link=false : 删除容器链接,但保留容器 。
    
        -v | --volumes=false :删除容器挂载的数据卷 。

    20. 导出容器:docker export  。    

    -o 指定导出的 tar 文件,也可以直接重定向实现

        如: docker export -o test.tar 容器名、id  或 docker export 容器名、id > test.tar 。

    21. 导入已导出的 tar 文件生成镜像:docker import 。   

     -c | --change=[ ] 导入时执行对容器进行修改的 Dockerfile 。

        如: docker import test.tar  -test/ubuntu:v1.o 。

    22. docker load 和 docker impoer 区别: 

     load 命令导入镜像存储文件到镜像库,将保存完整记录,体积大。
    
     import 命令导入一个快照到本地镜像库,会丢弃所有历史记录和元数据信息。   

    23. 搭建本地私有仓库:docker run -d -p 5000:5000 registry ,见书 P49 。

    这会自动下载并启动一个 registry 容器,创建本地的私有仓库 。     

     -v : 将镜像文件存放在本地指定路径,默认是将仓库创建在 /tmp/registry 目录下 。

    如:docker run  -d  -p  5000:5000  -v  /opt/data/registry:tmp/registry  registry 则会将上传的镜像放到 /opt/data/registry 目录下 。

    24. 数据卷是可供容器使用的特殊目录,它将主机操作目录直接映射进容器。

    -v 可以在 docker run 运行的容器内创建一个数据卷。多次重复使用则创建多个数据卷。
    
    - p 是将容器服务暴露的端口,是自动映射到本地主机的临时端口 。   
    

    如:docker run -d -p --name web -v /webapp train python app.py 

    用镜像 train  创建了容器 web ,并创建了一个数据卷挂载到容器的 /webapp 目录 。

    -v 也可以指定挂载一个本地已有目录到容器中去作为数据卷 。

    挂载数据卷的默认权限是 读写,可以用 ro 指定为只读,这样容器对所挂载数据卷内的内容就不能修改了 。 

    如: docker run -d -p --name web -v /src/webapp : /opt/web : ro  train python app.py 

    上面是加载主机的 /src/webapp 目录到容器的 /opt/web 目录 ,并且是只读 。

    // 25. 利用数据卷容器来迁移数据见书 P55 。

    26. 安装 ping :apt-get install -yqq inetutils-ping 。

    27. 通常 Dockerfile 分为四部分:基础镜像信息、维护者信息、镜像操作指令、容器启动时执行指令。

    参数说明:

    28. docker build 创建容器 :docker build Dockerfile文件名  。

        -t:指定生成镜像的标签名,即 tag 。
    
        -f:若 Dockerfile 不在当前路径下,可使用 -f 来指定 Dockerfile 路径 。

    如: docker build -t sshd:docker .    最后一个“.”表示使用当前路径下的 Dockerfile 文件 。

    // 29. docker 安装和使用各个操作系统见书 P71 。

    30. 安装 openssh-server : apt-get install openssh-server -y 。

    31. 查看端口占用: netstat -tunlp 。

    // 32. Docker Web 服务与应用(Apache、Nginx、Tomcat、Jetty、LAMP、CMS)见书 P83 。 

    33. 安装运行 mysql :( 使用官方镜像快速启动一个 mysql 服务实例 )

         docker run --name jy_mysql -e MYSQL_ROOT_PASSWORD=123 -d  mysql:latest 。

        执行完,mysql 就在 docker 中安装好了,可用 navicat 直接访问 。

        本地找不到的镜像会自动从Docker 仓库中下载最新版本。

        进入 mysql 容器: docker exec -it jy_mysql bash ,查看日志 :docker logs jy_mysql 。

    34. 安装运行 MongoDB: docker run --name mongoDB -d mongo 。

    35. 安装运行 Redis:docker run --name redis -d redis 。

    36. 安装运行  memcache : docker run --name memcache -d memcached 。

    // 37. 搭建 cassandra 集群见书 P109 。

              Docker 快速部署 RabbitMQ、Celery、Hadoop、Spark、Elasticsearch 见书P112 。

     

    --------------------------------------  以下更新于2018.7.28  --------------------------------------

     

    38.   Docker Compose安装命令:sudo pip install -U docker-compose。

    -f | --file :指定 compose 模板文件,默认为 docker-compose.yml ,可多次指定。
    
    -p | --projrct-name:指定项目名称,默认使用所在目录名称为项目名。
    
    --x-networking :使用 docker 可插拨网络后端特性。
    
    --x-network-driver DRIVER :指定网络后端驱动,默认为 brige。
    
    -v | --version :输出版本并退出。
    
    --verbose :输出更多调试信息。

     

    展开全文
  • 1.由浅入深学习docker技术,简单易学,1天学会docker常用知识点 2.包含常用操作,例如容器创建,查看容器信息,容器目录挂载等等操作 3.根据视频自己总结,截图是视频中的图, 截图引用来源:深入解析docker容器...
  • 这是一个精选版的docker技术讲座,格式为ppt格式,内容比较全面,适用于想要了解docker技术的用户。也可以参考作为讲解用PPT。
  • docker技术入门教程

    2021-05-30 07:44:10
    什么是容器虚拟化技术,深刻理解镜像、容器、仓库的各种概念和操作。通过该课程,帮助学习者掌握Dockerfile的编写和构建并使用Dockerfile来制作复杂镜像,能够使用容器卷完成容器间数据共享和持久化工作。能够在...
  • 好书推荐《Docker技术入门与实战》

    千次阅读 2019-04-07 00:08:00
    公众号回复 “11745” 获取下载地址 ,到网站51dr.cn查看全部资源! ... ...《Docker技术入门与实战》是中国首部Docker著作,一线Docker先驱实战经验结晶,来自IBM和新浪等多位技术专家联袂推荐! 《...
  • 分分钟了解Docker技术

    万次阅读 2018-07-17 20:02:44
    Docker简介 1. 虚拟化 1)什么是虚拟化 在计算机中,虚拟化(英语:Virtualization)是一种资源管理技术,是将计算机的各种 实体资源,如服务器、网络、内存及存储等,予以抽象、转换后呈现出来,打破实体结构间 的...
  • Docker技术资料.7z

    2020-02-28 14:39:53
    Docker技术资料,三部分内容 ①详细的docker相关PPT内容,适合想要学习docker技术或者正在学docker的,内容比较全面,可做为演讲PPT ②docker思维导图,可以用作业余时间复习,里面有Docker各种版本的安装方式,...
  • docker技术资料】-(机构内训资料)docker学习思维笔记
  • docker技术基础视频.rar

    2021-10-21 10:10:36
    01 docke容器技术基础入门zip,网盘文件,永久链接 02- Docker基础用法zip 03- Docker像管理基础zip 04-容器虚拟化网络概述zip 05-Docker容器网络zp 06 Docker存储卷 07- Dockerfile详解zp 08- Dockerfile详解zip 09-...
  • Docker技术集群与应用期末测试试卷 说明本试卷由选择题和简答题两部分组成满分100分 一选择题 说明共30题每题2分共计60分 针对以下题目请选择最符合题目要求的答案针对每一道题目所有答案都选对则该题 得分所选答案...
  • Docker技术实战

    2020-08-30 14:29:40
    课程详细地把Docker的基础知识点,技术点梳理清楚,然后加以练习实战,最后部署一个数据库,redis缓存,前段,后端都集群,并实现均衡负载,高可用,双机热备等特性的综合项目。
  • Docker技术入门(1)

    2021-09-25 09:51:03
    从0开始学docker从基本原理开始深入浅出带你了解docker的构建与操作内容系统全面可帮助开发人员运维人员快速部署Docker应用
  • Docker 技术与实践.pptx

    2019-12-19 09:32:37
    Docker 技术与实践: 一、Docker介绍及原理 什么是Docker? Docker VS VM Docker的生态圈 认识Docker Docker的原理 Docker文件系统 二、Docker基本操作 Docker三大核心 Docker操作-仓库 Docker操作...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 148,779
精华内容 59,511
关键字:

docker技术

友情链接: MCMC-master.zip