Docker基础

最新推荐文章于 2024-07-14 20:33:54 发布

nagisaLi

最新推荐文章于 2024-07-14 20:33:54 发布

阅读量211

点赞数 1

文章标签： docker

本文链接：https://blog.csdn.net/weixin_44391516/article/details/107641947

版权

这篇博客介绍了Docker的基础知识，包括安装、卸载、命令、镜像、容器数据卷和DockerFile的解析。讲解了Docker如何解决环境和配置问题，提供容器化的软件运行方式。内容涵盖docker命令如镜像、容器的创建和管理，以及DockerFile的使用，还涉及到Docker安装mysql和redis的实践。最后，讨论了如何将本地镜像推送到阿里云。

摘要由CSDN通过智能技术生成

Docker基础

一句话总结：

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

三要素：镜像/容器/仓库 Image/Containers/

镜像就是一个只读的模板。镜像可以用来创建Docker容器，一个镜像可以创建很多容器容器-> 对象镜像-> 类

docker利用容器独立运行的一个一组应用。容器是用镜像创建的运行实例

每个容器都是相互隔离的，保证安全的平台

仓库使用来存放镜像的地方

一. docker的安装和卸载

查询docker安装的包

yum list installed | grep docker
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-selinux \
docker-engine-selinux \
docker-engine

删除安装包

yum remove docker-ce.x86_64 ddocker-ce-cli.x86_64 -y

删除镜像/容器等

rm -rf /var/lib/docker

Centos6.8的安装

首先需要安装一个epel的依赖库

yum install -y epel-release

正式安装

yum install -y docker-io

安装后的配置文件

/etc/sysconfig/docker

启动docker后台服务

service docker start

二.docker的命令

docker run 命令干了什么

2.1 帮助命令

docker version   #docker的版本
docker info      #docker的基本信息
docker --help    #docker的命令大全

2.2 镜像命令

docker images

docker images 				#本地的仓库
docker images -a 			#本地的所有仓库（含中间映像层）
docker images -q 			#只显示镜像的ID
docker images --digests		#显示镜像的摘要信息
docker images --no-trunc 	#显示完整的镜像信息

docker search 某个镜像的名字

docker search tomcat 
docker search -s 30 tomact 			#只搜索点赞数超过30的tomcat的镜像
docker search --no-trunc tomcat 	#显示搜索出来镜像的所有信息

docker pull 镜像名称

docker pull tomcat 			##默认是拉取最近的版本
docker pull tomcat:latest 	  #冒号后面是tag 可以指定版本

docker rmi -f 镜像名称/镜像id

docker rmi -f hell0-world 
docker rmi -f $(docker images -qa)  ##删除所有镜像根据镜像id $这个符号相当于是种引用

2.3容器命令

首先有了镜像才会能创建容器以centos为例

docker pull centos

新建并运行容器

docker run [OPTIONS] image [COMMAND] [ARG...]
OPTIONS 参数说明
--name ：为新建的容器指定名称 不指定的话会有默认的名称
-d : 后台运行容器，并返回容器id，启动守护式容器
-i : 以交互模式运行容器，同从与-t同时使用
-t : 为容器重新分配一个为输入终端 
-P ：随机端口映射
-p : 指定端口映射 有以下四种格式
     ip:hostPort:containerPort
     ip::containerPort
     hostPort:containerPort
     containerPort
docker run -it centos 
接着就会直接进入centos中，因为是以-it的方式创建的容器，直接与centos进行了交互

列出现在正在运行的容器

docker ps [OPTIONS]
-a : 列出当前所有正在运行的容器+历史上运行过的容器
-l : 显示最近创建的容器
-n : 显示最近创建的n个容器
-q : 只显示容器的编号

退出容器

exit   		退出容器并停止容器
ctrl+P+Q     退出容器但不停止

退出后进入正在运行的容器

docker attach 容器id/name

启动停止的容器

docker start 容器id/name

重启容器

docker restart 容器id/name

温柔停止容器

docker stop 容器id/name

强制停止容器

docker kill 容器id/name

镜像以守护式容器的方式创建

docker run -d centos

但是这样就会有问题，当你使用docker ps 命令查看当前正在运行的容器，发现这个容器已经退出了

很重要的一点说明：docker容器后台运行，就必须要有一个前台进程

就算你将一个容器作为后台进程模式运行，就导致docker前台运行的应用

这样的容器后台启动后，就回立即自杀

需要指定你的后台的守护进程做事情他就不会自杀

docker run -d centos  /bin/bash -c "while true;" do echo hello ljf;sleep 5; done"     ##shell 脚本编程

查看容器的日志

docker logs -t -f --tail 容器id/name
-t : 加入时间戳
-f : 跟随最新的日志打印
--tail 数字 : 显示最后多少条记录

查看容器内运行的进程

docker top 容器id/name

查看容器内部细节

docker inspect 容器id/name

进入正在运行的容器并以命令行交互

docker attach 容器id/name    ##直接进入容器启动命令的终端，不会启动新的进程
docker exec -it 容器id/name bashShell ##是在容器外直接运行后面的bashShell 并返回结果

2.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 # 截取容器停止时的退出状态值

三. docker镜像

镜像是一种轻量级，可执行的独立软件包，用来打包软件运行环境和基本运行环境开发的软件，他包含运行某个软件所需的所有内容，包括代码，运行时，库，环境变量和配置文件

UnionFS

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

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等等。

在这里插入图片描述

docker 中拉取的centos镜像为什么比vm中小得多：第一就是因为去掉了那些硬件设备，还有就是内核kernel直接用的就是host的内核，所以重要的是rootfs

对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供 rootfs 就行了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别, 因此不同的发行版可以公用bootfs。

特点

Docker镜像都是只读的

当容器启动时，一个新的可写层被加载到镜像的顶部。

这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。

docker镜像commit操作补充

docker commit 提交容器使其变成镜像
docker commit -m="备注" -a="作者" 容器id 要创建镜像的名字:标签

四. docker容器数据卷

先来看看Docker的理念：

将运用与运行的环境打包形成容器运行，运行可以伴随着容器，但是我们对数据的要求希望是持久化的
容器之间希望有可能共享数据

Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保存下来，

那么当容器删除后，数据自然也就没有了。

为了能保存数据在docker中我们使用卷。

所以这个容器数据卷就有点类似于redis中的rdb和aof文件

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

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

特点：

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

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

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

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

创建docker的容器数据卷（其实就是数据同步和共享）

4.1直接命令创建

docker run -it -v/宿主机绝对路径目录:/容器内目录  镜像名

查看数据卷有没有挂载成功

docker inspect 镜像名

带权限创建容器数据库卷

docker run -it -v/宿主机绝对路径目录:/容器内目录:ro  镜像名
ro : read only
只允许主机读写

4.2 DockerFile创建

首先什么是dockerFile 可以理解成镜像的编译文件？

编写一个简单的dockerFile

# volume test

FROM centos

VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]  

CMD echo "finished,--------success1"

CMD /bin/bash

再通过docker build 命令构建一个以这个dockerFile为基础的新镜像

docker build -f 你的dockerFile所在的绝对路径目录 -t 新镜像名称 .

那么你的主机的数据卷目录在哪呢？

可以使用 docker inspect 来查看

4.3 数据卷容器

命名的容器挂载数据卷，其它容器通过挂载这个(父容器)实现数据共享，挂载数据卷的容器，称之为数据卷容器

说白了就是

可以实现数据卷容器的继承和共享

docker run -it --name xxxx --volumes-from xxx  镜像名称

就算删除了某个容器数据卷容器依旧能RW

结论

容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用为止

五. DockerFile 解析

是什么

DockerFile是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本

构建三步骤

编写dockerFile文件
docker build
docker run

文件的样子

FROM scratch								#继承的镜像 scratch是所有镜像的爸爸
ADD centos-7-x86_64-docker.tar.xz /			  #将文件放进这个镜像并且ADD命令会自动处理URL命令和解压tar压缩包	

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="20200504" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-05-04 00:00:00+01:00"

CMD ["/bin/bash"]							#容器运行（run）时需要运行的命令 会被覆盖 只dockerFile文件的最后一行CMD命令才生效  运行docker run  后面的参数也会影响

dockerFile文件的基本规范和内容

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

dockerFile文件执行的流程

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

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

* Dockerfile是软件的原材料

* Docker镜像是软件的交付品

* Docker容器则可以认为是软件的运行态。

Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H86fWBYk-1595930464173)(https://gitee.com/nagisaLi/lipang/raw/master/springboot_ssm/src/main/resources/static/imgMd/docker/%E4%B8%8B%E8%BD%BD%20(2)].png)

Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;
Docker容器，容器是直接提供服务的。

5.1 DockerFile体系结构（保留字指令）

FROM --------------------> 基础镜像，当前新镜像是基于哪个镜像

MAINTAINER --------------------> 镜像的维护者姓名和邮箱

RUN --------------------> 容器构建时需要运行的命令

EXPOSE --------------------> 当前镜像成为run后成为容器对外暴露的端口

WORKDIR --------------------> 指定在创建容器后，终端默认登录进去的工作目录，一个落脚点

ENV --------------------> 用来在构建镜像过程中设置环境变量（可用$引用）

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

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

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

CMD --------------------> 指定一个容器启动时要运行的命令，可以有多个CMD命令，但只有最后一行CMD生效

ENTRYPOINT --------------------> 与cmd一致,是追加，不会覆盖

ONBUILD --------------------> 当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发触发器父类的触发器被执行

5.2 dockerFile案例

centos 安装 vim编辑器

yum -y install vim

centos 安装 ifconfig

yum -y install net-tools

5.2.1 自定义一个mycentos 支持vim和ifconfig

FROM centos

ENV MY_PATH/usr/local

WORKDIR  $MY_PATH

RUN yum -y install vim 
RUN	yum -y install net-tools

EXPOSE 80
CMD echo "success ----ok"
CMD /bin/bash

查看镜像的变更历史

docker history 镜像id/name

5.2.2 CMD和ENTRYPOINT 的案例

FROM centos 
RUN yum -y install curl

CMD ["curl","-s","http://ip.cn"] 		# ip地址

CMD会被docker run后面的参数给覆盖

FROM centos 
RUN yum -y install curl

ENTRYPOINT ["curl","-s","http://ip.cn"] 
						# docker run 后面的参数会会追加到CMD后面

这个ENTRYPOINT 会在你启动这个容器的时候自动执行里面的命令

docker run 后面不加参数就默认执行 curl …

docker run -it centos -i ------------------> docker run -it curl -s -i http://ip.cn

5.2.3 ONBUILD 触发器

当你在docker file中写了一个 ONBUILD，并且build成为一个镜像后

又写了一个新的dockerFile，且FROM 这个刚build的镜像

当build这个dockerFile时，这个触发器就会执行（执行的是父镜像的触发器）

 FROM centos

MAINTAINER nagisa<1026455562@qq.com>

ENV MYPATH /usr/local

WORKDIR  $MYPATH
 
ONBUILD RUN echo "father"

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

5.2.4 自定义Tomcat9 镜像

创建一个新的目录

mkdir -p /ljfuser/mydockerFile/tomcat9

在这个目录创建c.txt

touch c.txt 		##等会会将这个文件以DockerFile的方式这个COPY

将jdk和tomcat的tar包放在这个目录下

构建DockerFile文件

FROM         centos
MAINTAINER    zzyy<zzyybs@126.com>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.8.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_171
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.8
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.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out

镜像到容器(两个容器数据卷)

docker run -d -p 9080:8080 --name myt9 
-v /zzyyuse/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test 
-v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.8/logs 
--privileged=true 
zzyytomcat9

因为有这个两个容器数据卷的存在，可以尝试着将测试的web服务test发布

在test目录下创建WEB-INF目录，并在创建web.xml

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

  xmlns="http://java.sun.com/xml/ns/javaee"

  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  id="WebApp_ID" version="2.5">

  <display-name>test</display-name>

</web-app>

返回上级目录,创建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>

接着重启这个容器 docker restart …

再去访问localhost:9080/test/a.jsp

成功访问

六. Docker安装mysql和redis

mysql

docker run -p 12345:3306 --name mysql 
-v /ljfuse/mysql/conf:/etc/mysql/conf.d 
-v /ljfuse/mysql/logs:/logs 
-v /ljfuse/mysql/data:/var/lib/mysql 
-e MYSQL_ROOT_PASSWORD=root 
-d mysql:5.6

数据备份(将整个数据库的sql备份下来)

docker exec myql服务容器ID sh -c ' exec mysqldump --all-databases -uroot -p"root" ' > /ljfuse/all-databases.sql

redis

docker run -p 6379:6379 
-v /ljfuse/myredis/data:/data 
-v/ljfuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf  -d redis:3.2 
redis-server /usr/local/etc/redis/redis.conf 
--appendonly yes    ###aof 数据持久化开启

使用redis-cli 连接到docker 中的redis