Docker入门

Docker概念

Docker 是世界领先的软件容器平台。开发人员利用 Docker 可以消除协作编码时“在我的机器上可正常工作”的问题。运维人员利用 Docker 可以在隔离容器中并行运行和管理应用，获得更好的计算密度。企业利用 Docker 可以构建敏捷的软件交付管道，以更快的速度、更高的安全性和可靠的信誉为 Linux 和 Windows Server 应用发布新功能。

Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口。它是目前最流行的 Linux 容器解决方案。Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。程序在这个虚拟容器里运行，就好像在真实的物理机上运行一样。有了 Docker，就不用担心环境问题。

为什么要使用Docker

容器除了运行其中应用外，基本不消耗额外的系统资源，使得应用的性能很高，同时系统的开销尽量小。传统虚拟机方式运行 10 个不同的应用就要起 10 个虚拟机，而Docker 只需要启动 10 个隔离的应用即可。

具体说来，Docker 在如下几个方面具有较大的优势。

1、更快速的交付和部署

对开发和运维（devop）人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。

开发者可以使用一个标准的镜像来构建一套开发容器，开发完成之后，运维人员可以直接使用这个容器来部署代码。 Docker 可以快速创建容器，快速迭代应用程序，并让整个过程全程可见，使团队中的其他成员更容易理解应用程序是如何创建和工作的。 Docker 容器很轻很快！容器的启动时间是秒级的，大量地节约开发、测试、部署的时间。

2、更高效的虚拟化

Docker 容器的运行不需要额外的 hypervisor 支持，它是内核级的虚拟化，因此可以实现更高的性能和效率。

3、更轻松的迁移和扩展

Docker 容器几乎可以在任意的平台上运行，包括物理机、虚拟机、公有云、私有云、个人电脑、服务器等。 这种兼容性可以让用户把一个应用程序从一个平台直接迁移到另外一个。

4、更简单的管理

使用 Docker，只需要小小的修改，就可以替代以往大量的更新工作。所有的修改都以增量的方式被分发和更新，从而实现自动化并且高效的管理。

Docker vs VM

从下图可以看出，VM是一个运行在宿主机之上的完整的操作系统，VM运行自身操作系统会占用较多的CPU、内存、硬盘资源。Docker不同于VM，只包含应用程序以及依赖库，基于libcontainer运行在宿主机上，并处于一个隔离的环境中，这使得Docker更加轻量高效，启动容器只需几秒钟之内完成。由于Docker轻量、资源占用少，使得Docker可以轻易的应用到构建标准化的应用中。但Docker目前还不够完善，比如隔离效果不如VM，共享宿主机操作系统的一些基础库等；网络配置功能相对简单，主要以桥接方式为主；查看日志也不够方便灵活。

Docker 在容器的基础上，进行了进一步的封装，从文件系统、网络互联到进程隔离等等，极大的简化了容器的创建和维护。使得 Docker 技术比虚拟机技术更为轻便、快捷。

作为一种新兴的虚拟化方式，Docker 跟传统的虚拟化方式相比具有众多的优势。Docker 容器的启动可以在秒级实现，这相比传统的虚拟机方式要快得多；Docker 对系统资源的利用率很高，一台主机上可以同时运行数千个 Docker 容器。

Docker相关概念

Docker 包括三个基本概念:

• 镜像（Image）：Docker 镜像（Image），就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。
• 容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
• 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。

Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

Docker	面向对象
容器	对象
镜像	类

image

概念	说明
Docker 镜像(Images)	Docker 镜像是用于创建 Docker 容器的模板，比如 Ubuntu 系统。
Docker 容器(Container)	容器是独立运行的一个或一组应用，是镜像运行时的实体。
Docker 客户端(Client)	Docker 客户端通过命令行或者其他工具使用 Docker SDK (https://docs.docker.com/develop/sdk/) 与 Docker 的守护进程通信。
Docker 主机(Host)	一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。
Docker Registry	Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。 Docker Hub(https://hub.docker.com) 提供了庞大的镜像集合供使用。 一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签对应一个镜像。 通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 <仓库名>:<标签> 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。
Docker Machine	Docker Machine是一个简化Docker安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装Docker，比如VirtualBox、 Digital Ocean、Microsoft Azure。

镜像就相当于打包好的版本，镜像启动之后运行在容器中，仓库就是装存储镜像的地方。

镜像就是上面说的集装箱,仓库就是超级码头,容器就是我们运行程序的地方.docker运行程序的过程就是去仓库把镜像拉到本地,然后用一条命令把镜像运行起来变成容器.

• build:构建,就是构建镜像.
• ship:运输,运输镜像,从仓库和主机运输.
• run:运行的镜像就是一个容器.
  build,ship,run和镜像,仓库,容器是一一对应的.

Docker 命令

#首先要在宿主机上安装Docker，Docker安装参考[官方安装文档](https://docs.docker.com/installation/)。 Docker命令也比较类似Git，支持push以及pull操作上传以及下载Docker镜像。 查看当前Docker的版本
docker version

#拉取docker镜像
docker pull image_name

#查看宿主机上的镜像，Docker镜像保存在/var/lib/docker目录下:
docker images
#删除镜像
docker rmi  docker.io/tomcat:7.0.77-jre7   或者  docker rmi b39c68b7af30

#查看当前有哪些容器正在运行
docker ps

#查看所有容器
docker ps -a

#启动、停止、重启容器命令：
docker start container_name/container_id
docker stop container_name/container_id
docker restart container_name/container_id

#后台启动一个容器后，如果想进入到这个容器，可以使用attach命令：
docker attach container_name/container_id

#停止所有docker容器
docker kill $(docker ps -q)

#删除容器的命令：
docker rm container_name/container_id

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

#查看当前系统Docker信息
docker info

#从Docker hub上下载某个镜像:
docker pull centos:latest
docker pull centos:latest

#查找Docker Hub上的nginx镜像
docker search nginx
#执行docker pull centos会将Centos这个仓库下面的所有镜像下载到本地repository。

#从当前目录下的Dockerfile(命名dockerfile好像也能识别，其他就不行了)建立镜像
sudo docker build -t reponame:tag .
#别忘了最后那个.！


sudo docker run -it --name blabla  -p <物理机>:<容器>(e.g. 127.0.0.1:3306:3306)  -v /your/local/path/:/map/path/in/docker/ -v /etc/localtime:/etc/localtime --net =host -d reponame:tag
# 启动容器 
#[-it 是启动交互和伪终端]
#[-p  <IP>:<宿主机端口>:<容器端口>  将宿主机（物理机)映射或者可以理解为绑定,<IP>可以指定，也可以不指定，不指定默认是0.0.0.0,建议还是指定]
#[-v  是挂载本机目录到到docker目录,最好每次都把-v /etc/localtime:/etc/localtime也带上，确保docker 容器内时间和服务器时间一致]
#[-d  是daemonize的意思，就是使容器成为守护进程，后台运作]  
#[--net是设置docker的网络模式，默认不设置的话就是bridge模式，现在设置为和物理机网络绑定的host模式，更多可以看 Docker的4种网络模式(http://www.cnblogs.com/gispathfinder/p/5871043.html)
#[--link 是容器链接]


#复习几个特别的IP：
#①127.0.0.1是本地回环地址，代指本机; [对于绑定在127.0.0.1的端口而言，外部无法访问，不对外打开，仅仅对内打开]
#②0.0.0.0 代表所有不清楚的IP，安全性差，也是指本机？;[对于绑定在0.0.0.0的端口而言，外部可以访问]
#③255.255.255.255 用人类的话说：“嘿，这屋子的所有人听着了！”
#④localhost  这个是域名，一般都是127.0.0.1，这种对应关系写在你的/etc/hosts里面

sudo docker exec -it blabla /bin/bash #在启动的容器blabla中运行/bin/bash
sudo docker exec -it blabla /the/path/of/your/command

sudo docker commit blabla  repo:tag  #提交保存容器到一个新的镜像repo:tag

#容器的导出和导入
sudo docker export 
sudo docker import 

#镜像的导出和导入
[文件]
sudo docker save repo:tag > backup.tar
sudo docker load < backup.tar
[dockerhub]
sudo docker login
sudo docker push repo:tag
sudo docker pull repo:tag 

image.png

镜像的概念更多偏向于一个环境包，这个环境包可以移动到任意的Docker平台中去运行；而容器就是你运行环境包的实例。你可以针对这个环境包运行N个实例。换句话说container是images的一种具体表现形式。你也可以认为镜像与你装载操作系统iso镜像是一个概念，容器则可理解为镜像启动的操作系统。一个镜像可以启动任意多个容器，即可以装载多个操作系统。

image.png

Docker命令参考表

docker命令选项列表

选项	说明	其他
–config [string]	客户端本地配置文件路径	默认为 ~/.docker
-D, –debug	启用调试模式
–help	打印用法
-H, –host list	通过socket访问指定的docker守护进程(服务端)	unix:// , fd:// , tcp://
-l, –log-level [string]	设置日志级别 (debug 、info 、warn 、error 、fatal)	默认为 info
–tls	启用TLS加密
–tlscacert [string]	指定信任的CA根证书路径	默认为 ~/.docker/ca.pem
–tlscert [string]	客户端证书路径	默认为 ~/.docker/cert.pem
–tlskey [string]	客户端证书私钥路径	默认为 ~/.docker/key.pem
–tlsverify	启用TLS加密并验证客户端证书
-v, –version	打印docker客户端版本信息

用于管理的子命令列表

选项	说明
container	管理容器
image	管理镜像
network	管理容器网络(默认为bridge、host、none三个网络配置)
plugin	管理插件
system	管理系统资源。其中, docker system prune 命令用于清理没有使用的镜像, 容器, 数据卷以及网络
volume	管理数据卷
swarm	管理Swarm模式
service	管理Swarm模式下的服务
node	管理Swarm模式下的docker集群中的节点
secret	管理Swarm模式下的敏感数据
stack	Swarm模式下利用compose-file管理服务

基础子命令列表

选项	说明
attach	进入运行中的容器, 显示该容器的控制台界面。注意, 从该指令退出会导致容器关闭
build	根据 Dockerfile 文件构建镜像
commit	提交容器所做的改为为一个新的镜像
cp	在容器和宿主机之间复制文件
create	根据镜像生成一个新的容器
diff	展示容器相对于构建它的镜像内容所做的改变
events	实时打印服务端执行的事件
exec	在已运行的容器中执行命令
export	导出容器到本地快照文件
history	显示镜像每层的变更内容
images	列出本地所有镜像
import	导入本地容器快照文件为镜像
info	显示 Docker 详细的系统信息
inspect	查看容器或镜像的配置信息, 默认为json数据
kill	-s 选项向容器发送信号, 默认为SIGKILL信号(强制关闭)
load	导入镜像压缩包
login	登录第三方仓库
logout	退出第三方仓库
logs	打印容器的控制台输出内容
pause	暂停容器
port	容器端口映射列表
ps	列出正在运行的容器, -a 选项显示所有容器
pull	从镜像仓库拉取镜像
push	将镜像推送到镜像仓库
rename	重命名容器名
restart	重启容器
rm	删除已停止的容器, -f 选项可强制删除正在运行的容器
rmi	删除镜像(必须先删除该镜像构建的所有容器)
run	根据镜像生成并进入一个新的容器
save	打包本地镜像, 使用压缩包来完成迁移
search	查找镜像
start	启动关闭的容器
stats	显示容器对资源的使用情况(内存、CPU、磁盘等)
stop	关闭正在运行的容器
tag	修改镜像tag
top	显示容器中正在运行的进程(相当于容器内执行 ps -ef 命令)
unpause	恢复暂停的容器
update	更新容器的硬件资源限制(内存、CPU等)
version	显示docker客户端和服务端版本信息
wait	阻塞当前命令直到对应的容器被关闭, 容器关闭后打印结束代码
daemon	这个子命令已过期, 将在Docker 17.12之后的版本中移出, 直接使用dockerd

run命令常用选项

选项	说明
-d	后台运行容器, 并返回容器ID；不指定时, 启动后开始打印日志, Ctrl + C 退出命令同时会关闭容器
-i	以交互模式运行容器, 通常与 -t 同时使用；
-t	为容器重新分配一个伪输入终端, 通常与 -i 同时使用
–name “anyesu-container”	为容器指定一个别名, 不指定时随机生成
-h docker-anyesu	设置容器的主机名, 默认随机生成
–dns 8.8.8.8	指定容器使用的DNS服务器, 默认和宿主一致
-e docker_host=172.17.0.1	设置环境变量
–cpuset=”0-2” or –cpuset=”0,1,2”	绑定容器到指定CPU运行
-m 100M	设置容器使用内存最大值
–net bridge	指定容器的网络连接类型, 支持 bridge / host / none / container 四种类型
–ip 172.18.0.13	为容器分配固定ip(需要使用自定义网络)
–expose 8081 –expose 8082	开放一个端口或一组端口, 会覆盖镜像设置中开放的端口
-p [宿主机端口]:[容器内端口]	宿主机到容器的端口映射, 可指定宿主机的要监听的ip, 默认为 0.0.0.0
-P	注意是大写的, 宿主机随机指定一组可用的端口映射容器 expose 的所有端口
-v [宿主机目录路径]:[容器内目录路径]	挂载宿主机的指定目录(或文件)到容器内的指定目录(或文件)
–add-host [主机名]:[ip]	为容器hosts文件追加host, 默认会在hosts文件最后追加 [主机名]:[容器ip]
–volumes-from [其他容器名]	将其他容器的数据卷添加到此容器
–link [其他容器名]:[在该容器中的别名]	添加链接到另一个容器, 在本容器hosts文件中加入关联容器的记录, 效果类似于 --add-host

Dockerfile，镜像和容器

Dockerfile 概念

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

镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。这个脚本就是 Dockerfile。

Dockerfile 是一个文本文件，其内包含了一条条的指令(Instruction)，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。有了 Dockerfile，当我们需要定制自己额外的需求时，只需在 Dockerfile 上添加或者修改指令，重新生成 image 即可，省去了敲命令的麻烦。

Dockerfile中文名叫镜像描述文件，是一个包含用于组合镜像目录的文本文档，也可以叫“脚本”。他通过读取Dockerfile中的指令安装步骤自动生成镜像。

Dockerfile文件格式

# This dockerfile uses the ubuntu image
# VERSION 2 - EDITION 1
# Author: docker_user
# Command format: Instruction [arguments / command] ..
 
# 1、第一行必须指定 基础镜像信息
FROM ubuntu
 
# 2、维护者信息
MAINTAINER docker_user docker_user@email.com
 
# 3、镜像操作指令
RUN echo "deb http://archive.ubuntu.com/ubuntu/ raring main universe" >> /etc/apt/sources.list
RUN apt-get update && apt-get install -y nginx
RUN echo "\ndaemon off;" >> /etc/nginx/nginx.conf
 
# 4、容器启动执行指令
CMD /usr/sbin/nginx

Dockerfile 分为四部分：基础镜像信息、维护者信息、镜像操作指令、容器启动执行指令。一开始必须要指明所基于的镜像名称，接下来一般会说明维护者信息；后面则是镜像操作指令，例如 RUN 指令。每执行一条RUN 指令，镜像添加新的一层，并提交；最后是 CMD 指令，来指明运行容器时的操作命令。

image.png

git+docker

一个管理代码，一个管理环境

git命令大合集

  git init repo  #初始化一个叫repo的本地git仓库
  #实际上就是创建一个repo的目录，然后目录下放一个.git，.git包含了git的所有记录，判断一个目录是否为git仓库，就看有没有.git目录，有.git目录往下都属于同一个git仓库
  #如果你把.git这个目录删除了，你的代码虽然还在，但是你的历史变更记录就全部没有了，所以一般别动这个.git

  git add file   #往暂存区添加一个叫file的文件
  git diff       #对比修改内容和git中最新记录的commit的区别，最好在add之前用git diff看一看，避免一些像加了空白键那种无效提交
  git add .      #往暂存区添加在git status中提示需要add的文件（git status不会提示被.gitignore忽略的文件）

  git commit  -m  "blablabla"  #把暂存区的内容正式提交到本地的当前分支,其中那个blablabla就是对本次提交的说明
  git commit 
  # 最近实践发现加了-m，我会尽可能挤成一行来写，但是push到github后，查看commit的时候就发现写的记录信息全部挤在一行，难看死了，有些还被忽略了
  # 所以不如直接git commit记录比较全面的信息
  # 不过之前得先指定git config --global core.editor /usr/bin/vim,不然貌似默认用的是vi，vi的话就有可能在你保存的时候会崩溃
  # 以至于你写的一堆提交信息全没了.

#git commit 还有一个-a的选项，是表示连同未add的文件改动也一同加进来，因为你可能add以后又改动了文件，而一般你前面add了内容就只用-m就可以了，不用-am

  git status  #查看当前所在git仓库情况
  git log     #查看提交历史，你会看到你自己之前commit时候的说明，各种blablabla
  git reflog  #查看操作历史

  git clone HTTPS/SSH #克隆一个项目
  # 常见的要么就是长成https型的(e.g. https://github.com/tesseract-ocr/tesseract.git)
  # 要么就是长成ssh型的(e.g. git@github.com:tesseract-ocr/tesseract.git)

  git remote -v  #查看远程代码仓库的信息
  git remote add origin HTTPS/SSH #添加一个叫origin远程仓库地址，一般克隆自带，如果是本地新创建的话就得执行这句，然后才能push
  git remote remove origin  #删除一个叫origin远程仓库地址
  git push origin <本地分支>:<远程分支>  #如果没有冒号后面的，此时默认推送到远程origin仓库的与<本地分支>同名的分支，如果不存在，则会被新建

  git fetch --all #这条命令一般用于如果有人远程push了一条分支到repo，你本地想要拉下来，直接checkout提示本地没有，就可以fetch全部分支了~

  git pull origin <远程分支>:<本地分支>   #如果没有冒号后面的，此时默认拉取并合并远程仓库origin的 <远程分支>到当前分支，pull相当于fetch+merge
  git pull --rebase origin dev  <远程分支>:<本地分支> #拉取远程git代码仓库origin的dev分支更新，并以重建的方式合并到本地分支
  #一般要是嫌麻烦，就像上面那样直接pull就好了，有些洁癖者喜欢用rebase保证本地的线性干净，本地可以rebase，远程就别这么做了

  git merge --no-ff dev master   #合并本地dev分支到master分支，洁癖者会为了干净历史加上--no-ff选项(--no-ff意思是no fast forward非快进式合并，某公司面试问了--no-ff含义)
  git merge --no-ff dev          #合并本地dev分支到本地当前分支，洁癖者会为了干净历史加上--no-ff选项

  #冲突解决：在pull 和merge的时候会因为合并双方文件内容不一样而导致冲突，它会显示给你发生冲突的文件，并自动在冲突文件中标注好不一样的段落
  #解决冲突其实已经有很多很好的工具了(比如vimdiff之类的)，但是我觉得这些工具都稍显得复杂不简约，所以我推荐直接用vim打开发生冲突的脚本，手动修改好，保存
  #用vim修改(sublime也不错)清晰方便，再add==>commit==>push就没问题了(第二次push是以你修改后提交为准，git这时候并不理会远程仓库的文件内容，直接覆盖过去~)
  #或者修改好冲突以后就git add冲突的文件，再git merge --continue或者git rebase --continue，省去了commit的功夫

  git branch   #显示本地所有分支
  git branch -D  dev #-D是-d --force的shotcut，强制删除dev本地分支
  git push origin  :dev  #删除远程仓库的dev分支，相当于把一个空分支push到远程仓库的dev上，等同于删除该分支。
  git checkout -b dev   #切换到dev分支,-b是没有dev分支时候才需要加上去的，这种情况下是创建并切换到dev分支的意思

  git checkout -- file  #撤销工作区中一个叫file的文件的修改
  git reset HEAD file   #撤销暂存区中一个叫file的文件到工作区中
  git reset --hard HEAD^  #回滚当前分支到上一个版本，注意末尾的^,有n个^说明回滚多上个版本，也就是回到多少次commit前

  #貌似把上面的file 换成*(wildcard)通配符来代指所有是可以的.我就经常多文件撤销工作区修改的时候git checkout -- * ，纯粹因为懒得一个个输入... 

在开发调试过程中，需要不断更新代码到Git库，然后使用Git库中的最新代码更新运行着的Docker容器，目前看来有如下两种方法，建议使用第二种。

1. 直接在容器中执行git命令，更新容器中的目录和文件（不推荐）

1. 首先，在构建容器镜像文件的时候，定义在Dockfile文件中并设置代码的Git库

RUN apt-get install -y git
 
RUN git config --global user.name "Xiangbin Han"
RUN git config --global user.email "youremail@mydomain.com"
 
RUN mkdir /home/myname/.ssh/
RUN chmod 700 /home/myname/.ssh/
ADD id_rsa /home/myname/.ssh/
RUN chmod 600 /home/myname/.ssh/id_rsa
 
RUN echo 'StrictHostKeyChecking no\nUserKnownHostsFile /dev/null' > /home/myname/.ssh/config
RUN chmod 644 /home/myname/.ssh/config
 
RUN su -myname -c \
  "git clone ssh://myname@gerrit.server.com:29418/myparent/myproject /home/myname/myproject \
  ; cd /home/myname/myproject \
  ; git fetch ssh://myname@gerrit.server.com:29418/myparent/myproject ${refs} \
  ; git checkout FETCH_HEAD"
 
RUN chown -R myname:mygroup /home/myname

2. 其次，基于构建的容器镜像文件启动容器

docker run -it --name container_name image_name:version

3. 需要更新运行中的容器的目录或文件时，执行如下Docker命令docker exec

docker exec container_name bash -c "cd /home/myname/myproject;git fetch ssh://myname@gerrit.server.com:29418/myparent/myproject ${GERRIT_REFSPEC};git checkout FETCH_HEAD"

2. 直接对容器实例执行docker cp命令，更新容器中的目录和文件（推荐）

docker cp ~/myproject/. container_name:/home/myname/myproject

3. 启动容器实例的时候，为容器加载Volume（推荐）

docker run -v /mnt/temp/myproject/:/home/myname/myproject ...

补充说明：

在生产环境中，由于代码比较稳定，可以在构建镜像的时候就代码直接加入到镜像中。

即在Dockfile中设置如下：

RUN COPY . /home/myname/myproject

说明，这种方法的弊端是必须能够在容器内部执行Git命令，因而不得不将私钥加入到容器，导致安全风险。

我在云端，使用Docker搭建了Git裸库，裸库中用Git hook来同步代码。使用Docker来运行应用，通过浏览器来检查结果。

因为，代码的编辑和运行环境的分离，开发工程师可以灵活的选择开发工具。开发工具可以是在线编辑器，也可以是本地的编辑器。
借助于Docker的灵活性，开发工程师可以快速配置出应用运行环境，并分享给开发团队成员。

如果说Dockerfile文件是拿来构建镜像的，那么docker-compose.yml文件就是用来编排服务的，它以一种更加简洁的方式来安排服务的启动顺序，依赖关系，运行指令。真正达到了“一键运行”的效果。

image.png

官方例子

image.png

clone

docker run --name repo alpine/git clone https://github.com/docker/getting-started.git 

各个参数解析：

• docker: Docker 的二进制执行文件。
• run: 与前面的 docker 组合来运行一个容器。
• --name 为容器repo 指定一个别名 alpine/git, 不指定时随机生成。repo 为指定要运行的镜像，Docker 首先从本地主机上查找镜像是否存在，如果不存在，Docker 就会从镜像仓库 Docker Hub 下载公共镜像 alpine/git的最新版本。
• clone https://github.com/docker/getting-started.git : 在启动的容器里执行的命令

以上命令完整的意思可以解释为：Docker 以alpine 镜像创建一个新容器，然后在容器里执行 git clone https://github.com/docker/getting-started.git 。

image.png

将容器repo的/git/getting-started下的getting-started目录 拷贝到(命令最后有一个. 表示当前目录)当前目录

docker cp repo:/git/getting-started/ .

image.png

build

为容器重新分配一个伪输入终端docker101tutorrial（即复制新建一个image，image id不一致，name重命名为docker101tutorrial）, 通常与 -i 同时使用（-i: 交互式操作。要退出终端，直接输入 exit）

cd getting-started
docker build -t docker101tutorrial .

image.png

Run

docker run -d -p 80:80 --name docker-tutorial docker101tutorial

新建并启动容器

• -d选项：表示后台运行，注：加了 -d 参数默认不会进入容器，想要进入容器需要使用指令 docker exec
• –name选项：指定运行后容器的名字为docker-tutorial,之后可以通过名字来操作容器 docker101tutorial为镜像
• -p选项：指定端口映射，格式为：hostPort:containerPort

image.png

docker container ls

image.png

Share

image.png

如果想要分享你的image，那么必须要有Docker Hub 的账号，打开Docker desk 登陆（未注册的可以hub.docker.com）

docker tag docker101tutorial tokenn/docker101tutorial

docker push tokenn/docker101tutorial

image.png

查看我们的分享
https://hub.docker.com/repositories

image.png

拉取

docker pull tokenn/docker101tutorial

image.png image.png