docker快速入门

简介：

Docker是基于Go语言实现的云开源项目。

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

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

解决了运行环境和配置问题的软件容器， 方便做持续集成并有助于整体发布的容器虚拟化技术。

---

组成：

• 镜像(image)

Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。

它也相当于是一个root文件系统。比如官方镜像 centos:7 就包含了完整的一套 centos:7 最小系统的 root 文件系统。

相当于容器的“源代码”，docker镜像文件类似于Java的类模板，而docker容器实例类似于java中new出来的实例对象。

• 容器(container)

1. 从面向对象角度

Docker 利用容器（Container）独立运行的一个或一组应用，应用程序或服务运行在容器里面，容器就类似于一个虚拟化的运行环境，容器是用镜像创建的运行实例。就像是Java中的类和实例对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器为镜像提供了一个标准的和隔离的运行环境，它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台

2. 从镜像容器角度

可以把容器看做是一个简易版的Linux环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序

• 仓库(repository)

仓库（Repository）是集中存放镜像文件的场所。

类似于

Maven仓库，存放各种jar包的地方；

github仓库，存放各种git项目的地方；

Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

最大的公开仓库是 Docker Hub(https://hub.docker.com/)，

存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云 、网易云等

• 总结：

Docker 本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就是image镜像文件。只有通过这个镜像文件才能生成Docker容器实例(类似Java中new出来一个对象)。

image文件可以看作是容器的模板。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

镜像文件

* image 文件生成的容器实例，本身也是一个文件，称为镜像文件。

容器实例

* 一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器

仓库

* 就是放一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候再从仓库中拉下来就可以了。

---

安装：

docker并非一个通用的容器工具，它依赖于已存在并运行的Linux内核环境。

docker实质上是在已经运行的Linux下制造了一个隔离的文件环境，因此它执行的效率几乎等同于所部署的Linux主机。

因此，docker必须部署在Linux内核的系统上。如果其他系统想部署docker就必须安装一个虚拟Linux环境。

在windows上部署docker的方法都是先安装一个虚拟机，并在安装Linux系统的虚拟机中运行docker。

安装地址：https://docs.docker.com/engine/install/centos/#installation-methods

步骤：

#1.安装需要的软件包
yum -y install gcc
yum -y install gcc-c++

#2.设置stable镜像仓库
yum install -y yum-utils
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

#3.更新yum软件包索引
yum makecache fast

#4.安装DOCKER CE
yum -y install docker-ce docker-ce-cli containerd.io

#5.启动docker
systemctl start docker

#6·测试
docker version

卸载：

systemctl stop docker
yum remove docker-ce docker-ce-cli containerd.io
rm -rf /var/lib/docker
rm -rf /var/lib/containerd

配置阿里云镜像加速：

运行：

运行一个镜像的一个实例：

docker run hello-world

run干了什么?

---

原理：

…

---

常用命令：

1.帮助启动类命令

• 启动docker： systemctl start docker

• 停止docker： systemctl stop docker

• 重启docker： systemctl restart docker

• 查看docker状态： systemctl status docker

• 开机启动： systemctl enable docker

• 查看docker概要信息： docker info

• 查看docker总体帮助文档： docker --help

• 查看docker命令帮助文档： docker 具体命令 --help

2.镜像命令

• 列出本地主机上的镜像：docker images [OPYIONS]

  • OPTIONS说明：

    • -a :列出本地所有的镜像（含历史映像层）
    • -q :只显示镜像ID。

  

  • REPOSITORY：表示镜像的仓库源
  • TAG：镜像的标签版本号
  • IMAGE ID：镜像ID
  • CREATED：镜像创建时间
  • SIZE：镜像大小

• 查找镜像：docker search [OPTIONS] 镜像名字

  • OPTIONS说明：

    • –limit : 只列出N个镜像，默认25个

    

  • NAME：镜像名称

  • DESCRIPTION：镜像说明

  • STARS：点赞数量

  • OFFICIAL：是否是官方的

  • AUTOMATED：是否是自动构建的

• 下载镜像：docker pull 镜像名字[:TAG]

• 查看镜像/容器/数据卷所占的空间：docker system df

• 删除镜像：docker rmi 某个XXX镜像名字ID

  • 删除单个：docker rmi -f 镜像ID
  • 删除多个：docker rmi -f 镜像名1:TAG 镜像名2:TAG
  • 删除全部：docker rmi -f $(docker images -qa)

3.容器命令

• 新建+启动容器：docker run [OPTIONS] IMAGE [COMMAND] [ARG…]

  • OPTIONS说明：

    • –name=“容器新名字” 为容器指定一个名称；
    • -d: 后台运行容器并返回容器ID，也即启动守护式容器(后台运行)；
    • -i：以交互模式运行容器，通常与 -t 同时使用；
    • -t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；也即启动交互式容器(前台有伪终端，等待交互)；
    • -P: 随机端口映射，大写P
    • -p: 指定端口映射，小写p
      • 

• 启动交互式容器(前台命令行)：docker run -it 容器名 /bin/bash

• 启动守护式容器(后台服务器)：docker run -d 容器名 （Docker容器后台运行,就必须有一个前台进程，否则将自动退出）

• 列出当前所有正在运行的容器：docker ps [OPTIONS]

  • OPTIONS说明：
    • -a :列出当前所有正在运行的容器+历史上运行过的
    • -l :显示最近创建的容器。
    • -n：显示最近n个创建的容器。
    • -q :静默模式，只显示容器编号。

• 退出容器： 两种退出方式

  • exit：run进去容器，exit退出，容器停止
  • ctrl+p+q：run进去容器，ctrl+p+q退出，容器不停止

• 启动已停止运行的容器：docker start 容器ID或者容器名

• 重启容器：docker restart 容器ID或者容器名

• 停止容器：docker stop 容器ID或者容器名

• 强制停止容器：docker kill 容器ID或容器名

• 删除已停止的容器：docker rm 容器ID

  • 一次性删除多个容器实例
    • docker rm -f $(docker ps -a -q)
    • docker ps -a -q | xargs docker rm

• 查看容器日志：docker logs 容器ID

• 查看容器内运行的进程：docker top 容器ID

• 查看容器内部细节：docker inspect 容器ID

• 进入正在运行的容器并以命令行交互：docker exec -it 容器ID /bin/bash

• 重新进入容器：docker attach 容器ID

  • attach 直接进入容器启动命令的终端，不会启动新的进程 用exit退出，会导致容器的停止。
  • exec 是在容器中打开新的终端，并且可以启动新的进程 用exit退出，不会导致容器的停止。

• 从容器内拷贝文件到主机上：

  • 容器→主机：docker cp 容器ID:容器内路径 目的主机路径

• 导入和导出容器：

  • export 导出容器的内容留作为一个tar归档文件[对应import命令]：docker export 容器ID > 文件名.tar
  • import 从tar包中的内容创建一个新的文件系统再导入为镜像[对应export]：cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号

• docker commit 容器ID 要创建的目标镜像名:[标签名]

  OPTIONS说明：

  • -a :提交的镜像作者；

  • -m :提交时的说明文字；

  提交容器副本使之成为一个新的镜像：docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

  演示：给centos安装vim命令，然后将centos容器打包为一个镜像，通过这个镜像创建的容器都是带vim命令的。

4.命令交互图

attach Attach to a running container # 当前 shell 下 attach 连接指定运行镜像

build Build an image from a Dockerfile # 通过 Dockerfile 定制镜像

commit Create a new image from a container changes # 提交当前容器为新的镜像

cp Copy files/folders from the containers filesystem to the host path #从容器中拷贝指定文件或者目录到宿主机中

create Create a new container # 创建一个新的容器，同 run，但不启动容器

diff Inspect changes on a container’s filesystem # 查看 docker 容器变化

events Get real time events from the server # 从 docker 服务获取容器实时事件

exec Run a command in an existing container # 在已存在的容器上运行命令

export Stream the contents of a container as a tar archive # 导出容器的内容流作为一个 tar 归档文件[对应 import ]

history Show the history of an image # 展示一个镜像形成历史

images List images # 列出系统当前镜像

import Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]

info Display system-wide information # 显示系统相关信息

inspect Return low-level information on a container # 查看容器详细信息

kill Kill a running container # kill 指定 docker 容器

load Load an image from a tar archive # 从一个 tar 包中加载一个镜像[对应 save]

login Register or Login to the docker registry server # 注册或者登陆一个 docker 源服务器

logout Log out from a Docker registry server # 从当前 Docker registry 退出

logs Fetch the logs of a container # 输出当前容器日志信息

port Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口

pause Pause all processes within a container # 暂停容器

ps List containers # 列出容器列表

pull Pull an image or a repository from the docker registry server # 从docker镜像源服务器拉取指定镜像或者库镜像

push Push an image or a repository to the docker registry server # 推送指定镜像或者库镜像至docker源服务器

restart Restart a running container # 重启运行的容器

rm Remove one or more containers # 移除一个或者多个容器

rmi Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]

run Run a command in a new container # 创建一个新的容器并运行一个命令

save Save an image to a tar archive # 保存一个镜像为一个 tar 包[对应 load]

search Search for an image on the Docker Hub # 在 docker hub 中搜索镜像

start Start a stopped containers # 启动容器

stop Stop a running containers # 停止容器

tag Tag an image into a repository # 给源中镜像打标签

top Lookup the running processes of a container # 查看容器中运行的进程信息

unpause Unpause a paused container # 取消暂停容器

version Show the docker version information # 查看 docker 版本号

wait Block until a container stops, then print its exit code # 截取容器停止时的退出状态值

5.将镜像打包发布到阿里云

步骤：

1.将本地容器制作为镜像

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

2.登录阿里云

https://promotion.aliyun.com/ntms/act/kubernetes.html

3.创建个人实例

4.创建镜像仓库

5.将镜像推送到阿里云registry

# 将镜像推送到阿里云
docker login --username=linging241 registry.cn-hangzhou.aliyuncs.com
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/linging/mycentos:[镜像版本号]
docker push registry.cn-hangzhou.aliyuncs.com/linging/mycentos:[镜像版本号]

6.从阿里云下载镜像到本地

docker pull registry.cn-hangzhou.aliyuncs.com/linging/mecentos:[镜像版本号]

6.将镜像打包到私有库

官方Docker Hub地址：https://hub.docker.com/，中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流。

---

docker容器数据卷

卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷。

• 将docker容器内的数据保存进宿主机的磁盘中

• 运行一个带有容器卷存储功能的容器实例

  • docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名
  • docker run -it --privileged=true -v /usr/local/me/data:/usr/local/tmp/data centos /bin/bash
  • docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名 容器目录默认是rw读写
  • docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名 容器目录只读

• 容器卷的特点：

  • 特点：

    1：数据卷可在容器之间共享或重用数据

    2：卷中的更改可以直接实时生效

    3：数据卷中的更改不会包含在镜像的更新中

    4：数据卷的生命周期一直持续到没有容器使用它为止

• 卷的继承和共享

  • docker run -it --privileged=true --volumes-from 父容器名 --name u2 镜像名
  • docker run -it --privileged=true --volumes-from u1 --name u2 镜像名
  • 相当于容器1，容器2…容器n映射宿主机中的同一目录，然后共享数据，任意容器或者宿主机的内容修改都会实时同步。

---

docker安装常用软件

1.安装tomcat

#拉取镜像
docker pull tomcat:8.0.17
#运行容器
docker run -it -p 8080:8080 tomcat:8.0.17
或
docker run -d -p 8080:8080 tomcat:8.0.17
#访问
http://ip:8080

2.安装mysql

#拉取镜像
docker pull mysql:5.7.5
#运行容器
docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.5
#进入容器
ocker exec -it 容器ID /bin/bash
#进入mysql
mysql -uroot -p

插入中文会报错。

#查看字符编码
SHOW VARIABLES LIKE 'character%';


#将mysql的数据挂在到宿主机
docker run -d -p 3306:3306 --privileged=true -v /usr/local/mysql/log:/var/log/mysql -v /usr/local/mysql/data:/var/lib/mysql -v /usr/local/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7.5

#新建配置文件
cd /usr/local/mysql/conf
vi my.cnf

输入以下内容：
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8

#重启mysql容器
docker restart 容器ID

插入中文不会报错。

3.安装redis

#拉取镜像
docker pull redis:6.0.8

#运行容器
docker run -p 6379:6379 --privileged=true -v /usr/local/redis/redis.conf:/etc/redis/redis.conf -v /usr/local/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf

#进入容器运行redis-cli
docker exec -it 容器ID redis-cli

4.安装nginx

5.安装mysql主从

6.安装redis集群模式

7.docker运行微服务项目

1. 编写微服务项目docker-boot，打成jar包

2. 编写Dockerfile文件

   #构建java8镜像
   FROM centos:7
   MAINTAINER linging<[email protected]>
    
   #安装java8及lib库
   RUN yum -y install glibc.i686
   RUN mkdir /usr/local/java
   #ADD 是相对路径jar,把jdk-8u11-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
   ADD jdk-8u11-linux-x64.tar.gz /usr/local/java/
   #配置java环境变量
   ENV JAVA_HOME /usr/local/java/jdk1.8.0_11
   ENV JRE_HOME $JAVA_HOME/jre
   ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
   ENV PATH $JAVA_HOME/bin:$PATH
    
   CMD ["java","-version"]
   
   #构建命令 docker build -t java:8 .
   

   #构建微服务镜像
   FROM java:8
   # 作者
   MAINTAINER linging
   # VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
   VOLUME /tmp
   # 将jar包添加到容器中并更名为linging_docker.jar
   ADD docker-boot-1.0-SNAPSHOT.jar linging_docker.jar
   # 运行jar包
   RUN bash -c 'touch /linging_docker.jar'
   ENTRYPOINT ["java","-jar","/linging_docker.jar"]
   #暴露6001端口作为微服务
   EXPOSE 6001
   
   #构建镜像命令  docker build -t test_java_app:1.0 .
   #运行   docker run -d -p 6001:6001 test_java_app:1.0
   #测试
   #curl 127.0.0.1:6001/order/index
   #curl 127.0.0.1:6001/order/docker
   #或者打开浏览器输入：192.168.159.100:6001/order/index
   

8.linux下安装jdk

#上传安装包 jdk-8u11-linux-x64.tar.gz 到目录 /usr/localjava/
#解压
tar -zxvf jdk-8u11-linux-x64.tar.gz

#配置环境变量
vi /etc/profile
#写入以下内容
export JAVA_HOME=/usr/local/java/jdk1.8.0_11
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar

#配置文件生效
source /etc/profile
#查看版本
java -version

9.安装hugegraph

#拉取hugegraph镜像，服务
docker pull hugegraph/hugegraph:latest
#启动容器

docker run -itd --name=graph -p 8080:8080 hugegraph/hugegraph

docker run -itd -p 8080:8080 --privileged=true -v /usr/local/hugegraph/gconf:/hugegraph/conf hugegraph/hugegraph
#测试
curl 0.0.0.0:8080


#拉取hugegraph/hubble，UI界面
docker pull hugegraph/hubble:latest
#启动容器
docker run -itd --name=fe -p 8088:8088 hugegraph/hubble

10、安装tinkerpop

docker pull tinkerpop/gremlin-server:3.5.0
docker pull tinkerpop/gremlin-console:3.5.0

docker run -p 8182:8182 --privileged=true -v /usr/local/tinkerpop/conf/gremlin-server2.yaml:/opt/gremlin-server/conf/gremlin-server2.yaml -v /usr/local/tinkerpop/data:/opt/gremlin-server/data -d tinkerpop/gremlin-server:3.5.0 conf/gremlin-server2.yaml

dockerFile文件详解

1.dockerFile是什么？

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

构建三步骤

• 编写Dockerfile文件

• docker build命令构建镜像

• docker run依镜像运行容器实例

2.DockerFile构建过程解析

Dockerfile内容基础知识

1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2. 指令按照从上到下，顺序执行

3. #表示注释

4. 每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程

1. docker从基础镜像运行一个容器

2. 执行一条指令并对容器作出修改

3. 执行类似docker commit的操作提交一个新的镜像层

4. docker再基于刚提交的镜像运行一个新容器

5. 执行dockerfile中的下一条指令直到所有指令都执行完成

DockerFile与Docker镜像与Docker容器的关系

1. Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;

2. Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;

3. Docker容器，容器是直接提供服务的。

3.DockerFile常见保留字指令

https://docs.docker.com/engine/reference/builder/

• FROM：基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from

• MAINTAINER：镜像维护者的姓名和邮箱地址

• RUN：容器构建时需要运行的命令。RUN是在 docker build时运行

  • shell格式：RUN <命令行命令> #<命令行命令>等同于，在终端操作的shell命令。如：RUN yum -y install vim
  • exec格式：RUN [“可执行文件”,“参数1”,“参数2”] #如：RUN[“./test.php”,“dev”,“offline”] <==> RUN ./test.php dev offline

• EXPOSE：当前容器对外暴露出的端口

• WORKDIR：指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点

• USER：指定该镜像以什么样的用户去执行，如果都不指定，默认是root

• ENV：用来在构建镜像过程中设置环境变量

• VOLUME：容器数据卷，用于数据保存和持久化工作

• ADD：将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包

• COPY：类似ADD，拷贝文件和目录到镜像中。 将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置

  • COPY src dest
  • COPY [“src”, “dest”]
  • ：源文件或者源目录
  • ：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。

• CMD：指定容器启动后的要干的事情。CMD是在docker run 时运行

  • 

  • Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

• ENTRYPOINT：也是用来指定一个容器启动时要运行的命令

  • 类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖， 而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序

  • 

  • ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。

    当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成 ""。案例如下：

  • FROM nginx
    
    ENTRYPOINT ["nginx", "-c"] #定参
    CMD ["/etc/nginx/nginx.conf"] #变参
    

    是否传参	按照dockerfile编写执行	传参运行
    Docker命令	docker run nginx:test	docker run nginx:test -c /etc/nginx/new.conf
    衍生出的实际命令	nginx -c /etc/nginx/nginx.conf	nginx -c /etc/nginx/new.conf

  • 如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

4.编写dockerfile文件

docker pull centos:7

FROM centos:7
MAINTAINER linging<[email protected]>
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u11-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
ADD jdk-8u11-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_11
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
 
EXPOSE 80

CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

#构建镜像,最后的点表示当前目录，即Dockerfile文件所在的目录
docker build -t centosjava8:1.0 .
#构建完成运行
docker run -it centosjava8:1.0 /bin/bash
#运行命令
ifconfig
vim 
java -version

docker网络

docker-compose容器编排

Compose 是 Docker 公司推出的一个工具软件，可以管理多个 Docker 容器组成一个应用。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。

1.官网：

https://docs.docker.com/compose/compose-file/compose-file-v3/

2.安装：

https://docs.docker.com/compose/install/

安装步骤：

curl -SL https://github.com/docker/compose/releases/download/v2.17.1/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

chmod +x /usr/local/bin/docker-compose

docker-compose --version

卸载：

rm /usr/local/bin/docker-compose

3.核心概念

• 一文件

  • docker-compose.yml

• 两要素

  • 服务（service）一个个应用容器实例，比如订单微服务、库存微服务、mysql容器、nginx容器或者redis容器

  • 工程（project）由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。

4.Compose使用的三个步骤

• 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件

• 使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。

• 最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线

5.Compose常用命令

• docker-compose -h # 查看帮助

• docker-compose up # 启动所有docker-compose服务

• docker-compose up -d # 启动所有docker-compose服务并后台运行

• docker-compose down # 停止并删除容器、网络、卷、镜像。

• docker-compose exec yml里面的服务id # 进入容器实例内部 docker-compose exec docker-compose.yml文件中写的服务id /bin/bash

• docker-compose ps # 展示当前docker-compose编排过的运行的所有容器

• docker-compose top # 展示当前docker-compose编排过的容器进程

• docker-compose logs yml里面的服务id # 查看容器输出日志

• docker-compose config # 检查配置

• docker-compose config -q # 检查配置，有问题才有输出

• docker-compose restart # 重启服务

• docker-compose start # 启动服务

• docker-compose stop # 停止服务

6.Compose编排微服务

1.准备镜像：blog_docker:1.0、redis:6.0.8、mysql:5.7.5

2.编写docker-compose.yml文件，如下内容：

version: "3"

services:
  microService:
    image: blog_docker:1.0
    container_name: blog
    ports:
    - "8080:8080"
    volumes:
    - /app/microService:/data
    networks:
     - linging_net
    depends_on:
      - redis
      - mysql

  redis:
    image: redis:6.0.8
    ports:
    - "6379:6379"
    volumes:
    - /usr/local/redis/redis.conf:/etc/redis/redis.conf
    - /usr/local/redis/data:/data
    networks:
     - linging_net
    command: redis-server /etc/redis/redis.conf

  mysql:
    image: mysql:5.7.5
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'lingingblog'
      MYSQL_USER: 'root'
      MYSQL_PASSWORD: '123456'
    ports:
    - "3306:3306"
    volumes:
    - /usr/local/mysql/data:/var/lib/mysql
    - /usr/local/mysql/conf:/etc/mysql/conf.d
    - /usr/local/mysql/log:/var/log/mysql
    networks:
     - linging_net
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks:
  linging_net:

3.启动docker-comppse服务

docker-compose up -d

4.查看容器

docker ps

由于ip地址可能会变，所以在微服务中可以将ip写为对应的服务名称，比如mysql，redis

docker可视化工具

docker容器监控

sql

redis:
image: redis:6.0.8
ports:
- “6379:6379”
volumes:
- /usr/local/redis/redis.conf:/etc/redis/redis.conf
- /usr/local/redis/data:/data
networks:
- linging_net
command: redis-server /etc/redis/redis.conf

mysql:
image: mysql:5.7.5
environment:
MYSQL_ROOT_PASSWORD: ‘123456’
MYSQL_ALLOW_EMPTY_PASSWORD: ‘no’
MYSQL_DATABASE: ‘lingingblog’
MYSQL_USER: ‘root’
MYSQL_PASSWORD: ‘123456’
ports:
- “3306:3306”
volumes:
- /usr/local/mysql/data:/var/lib/mysql
- /usr/local/mysql/conf:/etc/mysql/conf.d
- /usr/local/mysql/log:/var/log/mysql
networks:
- linging_net
command: --default-authentication-plugin=mysql_native_password #解决外部无法访问

networks:
linging_net:

3.启动docker-comppse服务

```shell
docker-compose up -d

4.查看容器

docker ps

由于ip地址可能会变，所以在微服务中可以将ip写为对应的服务名称，比如mysql，redis

docker可视化工具

docker容器监控