docker快速入门

Linging_24

已于 2023-08-03 19:35:05 修改

阅读量778

点赞数

分类专栏： docker 文章标签： docker 容器运维

于 2023-08-02 22:34:36 首次发布

本文链接：https://blog.csdn.net/Linging_24/article/details/132072692

版权

docker 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

简介：

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)

从面向对象角度

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

从镜像容器角度

可以把容器看做是一个简易版的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]

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运行微服务项目

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

编写Dockerfile文件

#构建java8镜像
FROM centos:7
MAINTAINER linging<linging@163.com>
 
#安装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内容基础知识

每条保留字指令都必须为大写字母且后面要跟随至少一个参数
指令按照从上到下，顺序执行
#表示注释
每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程

docker从基础镜像运行一个容器
执行一条指令并对容器作出修改
执行类似docker commit的操作提交一个新的镜像层
docker再基于刚提交的镜像运行一个新容器
执行dockerfile中的下一条指令直到所有指令都执行完成

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

在这里插入图片描述

Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时会真正开始提供服务;
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”]
- <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指令，他两个组合会变成 <ENTRYPOINT> "<CMD>"。案例如下：

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<linging@163.com>
 
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容器监控

Linging_24

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
docker快速入门

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

扫一扫