初识docker

最新推荐文章于 2022-07-14 14:49:14 发布
最新推荐文章于 2022-07-14 14:49:14 发布
阅读量154 收藏
点赞数
分类专栏： docker-k8s 文章标签： docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43025075/article/details/109750304
版权

docker学习

JavaEE java springmvc、springboot、mybatis…

docker Go k8s、Jenkins…

docker是什么

一次封装，到处运行

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

docker三要素：镜像、容器、仓库

docker能干嘛

虚拟机缺点:
  • 资源占用多
  • 冗余步骤多
  • 启动慢
docker和传统虚拟化方式的不同之处：
  • 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需的应用程序
  • 容器内的应用进程直接运行于宿主机的内核，容器内没有自己的内核，而且也没有进行硬件虚拟,因此容器要比传统的虚拟机更为轻便
  • 每个容器之间相互隔离，每个容器有自己的文件系统，容器之间进程不回相互影响，能区分计算资源
DevOps(开发、运维)
  • 更快速的应用交付和部署
  • 更加便捷的升级和扩缩容
  • 更简单的系统运维
  • 更加高效的计算资源利用

容器

docker利用容器(container)独立运行的一个或一组应用;容器是用镜像创建的运行实例

它可以被启动、开始、停止、删除；每个容器都是相互隔离的、保证安全的平台

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

容器定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的

仓库

仓库（Repository）是集中存放镜像文件的场所。
仓库(Repository)和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库（Public）和私有仓库（Private）两种形式。
最大的公开仓库是Docker Hub(https://hub.docker.com/)，
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等

docker常用命令

帮助命令
//常看docker版本
docker version

//查看docker的具体信息
docker info

//帮助命令
docker --help
镜像命令
//列出本地主机上的镜像
docker images
                -a                  列出本地所有的镜像
                -q                  列出本地镜像的id
                -qa                 列出本地所有镜像的id
                --digests           显示镜像的摘要信息
                --no-trunc          显示完整的镜像信息

//查找镜像
docker search 镜像名称
                -s 30 镜像名称          列出点赞数大于30的镜像
                --automated             列出自动构建的镜像

//下载镜像
docker pull 镜像名称:镜像版本

//删除镜像
docker rmi 镜像名称:镜像版本
            -f 镜像ID                               删除单个镜像
            -f 镜像名称:镜像版本 镜像名称:镜像版本  删除多个镜像
            -f $(docker images -qa)                 删除所有镜像
容器命令
//新建并启动容器    **启动交互式容器**
docker run -it 镜像ID --name 别名

//列出当前所有正在运行的容器
docker ps
            -a          列出当前所有容器
            -l          列出上一次运行的容器
            -n 3        列出上三次运行的容器
            -lq         列出上一次运行的容器的ID
            
//退出容器
exit                    关闭容器并退出
ctrl + P + Q            退出但不关闭

//启动容器
docker start 容器ID或者名称

//重启容器
docker restart 容器ID或者名称

//停止容器
docker stop 容器ID

//强制停止容器
docker kill 容器ID或者名称

//删除停止的容器
docker rm 镜像ID
        -f 镜像ID       关闭正在运行的容器并删除
        docker rm -f $(docker ps -a -q)     一次性删除多个容器
        docker ps -a -q | xargs docker rm
        

==重要==
//创建并启动容器    **启动守护式容器**
docker run -d 容器名称 
                        /bin/sh -c  "while true;do echo hello zzyy;sleep2;done"       写一个脚本，在日志循环打印一句话

//查看容器日志
docker logs -f -t --tail 容器ID
    -t是加入时间戳
    -f是跟随最新的日志打印（不停的追加）
    --tail 数字  显示最后多少条

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

//查看容器内部的细节
docker inspect 容器ID


//进入正在运行的容器，并以命令行交互
docker attach 容器ID      相当于   docker exec -t 容器ID /bin/bash           (直接进入容器启动命令终端，不会启动新的进程)
ls -l /tmp

docker exec -t 容器ID ls -l /tmp        (在容器中打开新的终端，并且可以启动新的进程；直接得到结果，没有进入容器)

//从容器内拷贝文件到主机上
docker cp 容器ID:容器内文件路径 目的主机的路径

镜像原理

UnionFS（联合文件系统)

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

特性

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

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionF。
==bootfs(boot file system)==主要包含bootioader和kernel,bootloader主要是引导加载kernel,Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的LinuxUnix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs (root file system)，在boots之上。包含的就是典型Linux系统中的/dev, /proc, lbin, /etc等标准目录和文件。roots就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。

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

优势：共享资源
  • 有多个镜像都从相同的base镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

镜像commit

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

1、从hub上下载Tomcat镜像到本地并成功运行

//i-交互    t-终端
docker run -it -p 8888:8080 tomcat      端口自定义
docker run -it -P tomcat                端口随机分配
//后台启动，没有日志输出
docker run -d -p 7777:8080 tomcat

2、故意删除上一步镜像生产Tomcat容器的文档

//运行容器
docker exec -it 容器id /bin/bash
//f参数表示删除不询问
rm -rf docs

3、当前Tomcat运行实例是一个没有文档的容器。以他为模板commit一个没有doc的Tomcat新镜像atguigu/mytomcat

docker commit -a "作者" -m="del tomcat docs" 容器id atguigu/mytomcat:1.1

4、启动我们的新镜像和原来的对比

容器数据卷

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

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

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

特点:

1:数据卷可在容器之间共享或重用数据
2:卷中的更改可以直接生效
3:数据卷中的更改不会包含在镜像的更新中
4:数据卷的生命周期一直持续到没有容器使用它为

容器添加数据卷

exit：退出停止容器（出门关灯）
Ctrl+P+Q：退出容器（出门没关灯）

1、直接命令添加

  • 命令
//-v    卷(volume)的英文缩写
-容器内执行-
docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名称
  • 查看数据卷是否挂载成功
docker inspect 容器id       
//"Volumes": {"/容器内目录": "/宿主机绝对路径目录"}
//"VolumesRW": {{"/容器内目录": true}           -读写操作-
//"HostConfig": {"Binds:[/宿主机绝对路径目录:/容器内目录]"}
  • 容器和宿主机之间数据共享
-宿主机内执行-
touch host.txt
  • 容器停止退出后。宿主机修改后的数据是否同步
可以
  • 命令(带权限)
//只读（read only）
docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名称

2、dockerFile添加

1.根目录下新建mydocker文件夹并进入

2.可在dockerfile中使用volume指令来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer","/dataVolumeContainer2"]
说明:
出于可移植和分享的考虑，用-v主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
由于宿主机目录是依赖于特定宿主机的，并不能够保证布所有的宿主机上都存在这样的特定目录。

3.file构建
#volume test
FROM centos
VOLUME["/dataVolumeContainer","/dataVolumeContainer2"]
CMD echo "finished,---success"
CMD /bin/bash

4.build后生成镜像
docker build -f /dockerfile路径 -t 镜像名称 .

5.run容器
docker run -it 镜像名称

Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied

解决办法:在挂载目录后多加一个–privileged=true参数即可

容器间传递共享

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

1、先启动一个父容器dc01 在dataVolumeContainer2新增内容
docker run -it --name dc01 zzyy/centos

cd dataVolumeContainer2

touch dc01.txt

2、dc02/dc03继承自do01，dc02/dc03分别在dataVolumeContainer2各自新增内容
docker run -it --name dc02 --volume-from dc01 zzyy/centos

cd dataVolumeContainer2

touch dc02.txt

docker run -it --name dc03 --volume-from dc01 zzyy/centos

cd dataVolumeContainer2

touch dc03.txt

3、回到dc01可以看到02、03各自添加的都能共享

4、删除dc01，dc02修改后，dc03可否访问   --可以访问
docker rm -f dc01

docker ps

docker attach dc02

pwd

ll

touch dc02_update.txt

docker attach dc03

pwd

ll

5、删除dc02后dc03可否访问   --可以访问

6、新建dc04继承dc03后再删除dc03     --可以访问

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

DockerFile解析

1、手动编写一个dockerfile文件，必须符合dockerfile的规范

2、有这个文件后，直接docker build命令执行，获得一个自定义的镜像

3、run
dockerfile介绍

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

构建三步骤：

  • 1.编写dockerfile文件
  • 2.docker build
  • 3.docker run
dockerfile构建过程解析

1、dockerfile内容基础知识

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

2、docker执行dockerfile的大致流程

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

小总结

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段：
- Dockerfile是软件的原材料
- Docker镜像是软件的交付品
- Docker容器则可以认为是软件的运行态

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

1、Dockerfle，需要定义一个Dockerfle，Dockerfle定义了进程需要的一切东西。Dockerfle涉及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计namespace的权限控制)等等;
2、Docker镜像，在用Dockerfle定义一个文件之后，docker build时会产生一个Docker镜像，当运行Docker镜像时，会真正开始提供服务;
3、Docker容器，容器是直接提供服务的。
dockerfile体系结构（保留字指令）
FROM            基础镜像，当前将要编写的镜像基于的镜像

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

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

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

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

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

    ENV MY_PATH /usr/mytest
    这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样;也可以在其它指令中直接使用这些环境变量，
    比如:WORKDIR $MY_PATH

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

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

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

CMD             指定一个容器启动时要运行的命令
                dockerfile中可以有多个CMD命令，但只有最后一个生效，CMD会被docker run之后的参数替换

ENTRYPOINT      指定一个容器启动时要运行的命令
                ENTRYPOINT的目的和CMD一样，都是在指定容器启动程序及参数
                追加，不替换

ONBUILD         当构建一个被继承的Dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被触发
案例

1、base镜像(scratch)
docker hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的

2、自定义镜像mycentos

目的：

  • 登录后的默认路径
  • vim编辑器
  • 查看网络配置ficonfig支持
1.编写

FROM centos
MAINTAINER dxh<18434762255@163.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

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

EXPOSE 80

CMD /bin/bash


2.构建

docker build -f /mydocker/DockerFile -t mycentos:1.0 .


3.运行

docker run -it mycentos:1.0


4.列出镜像的变更历史

docker history 镜像id

3、CMD/ENTRYPOINT镜像案例 - 区别

都是指定一个容器启动时要运行的命令

  • CMD

dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换
Case
Tomcat案例 docker run -it -p 8888:8080 tomcat ls -l

  • ENTRYPOINT

docker run之后的参数会被当做参数传递给ENTRYPOINT，之后形成新的命令组合
Case
制作CMD版可以查询ip信息的容器
```
FROM centos
RUN yum install -y curl
CMD “curl”,"-s",“http://ip.cn”

    FROM centos
    RUN yum install -y curl
    ENTRYPOINT "curl","-s","http://ip.cn"
```

FROM centos
RUN yum install -y curl
ENTRYPOINT "curl","-s","http://ip.cn"
ONBUILD RUN echo "---father onbuild---"

4、自定义镜像Tomcat9

1.新建目录 mkdir -p /dxhuse/mydockerfile/tomcat9

2.在上述目录下 touch c.txt

3.将jdk和Tomcat安装的压缩包拷贝进上一步目录

4.在/dxhuse/mydockerfile/tomcat9目录下新建dockerfile文件

FROM centos
MAINTAINER dxh<haoshen0611@163.com>

#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下并重命名为cincontainer.txt
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


5.构建
docker build -t dxh9 .

6.运行run
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 镜像名称


7.验证  网页输入localhost:9080

8.结合前述的容器卷将测试的web服务test发布

docker常用安装

1、总体步骤

  • 搜索
  • 拉取
  • 查看
  • 启动
  • 停止
  • 移除

2、安装MySQL

docker search mysql

docker pull mysql:5.6

docker run -p 12345:3306 --name mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/logs:/logs -v /zzyyuse/mysql/logs:/logs -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6

命令说明:
-p 12345:3306   将主机的12345端口映射到docker容器的3306端口
--name mysql    运行服务名字
-v /zzyyuse/mysql/conf:/etc/mysql/conf.d 将主机zzyyuse/mysql录下的conf/my.cnf挂载到容器的/etc/mysql/conf.d
-v /zzyyuse/mysql/logs:/logs    将主机/zzyyuse/mysql目录下的logs目录挂载到容器的logs
-v /zzyyuse/mysql/data:/var/lib/mysql   将主机/zzyyuse/mysql目录下的data目录挂载到容器的/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456   初始化 root用户的密码
-d mysql:5.6                    后台程序运行mysql5.6


docker exec -it MySQL运行成功后的id /bin/bash

mysql -uroot -p

3、安装Redis

docker search redis

docker pull redis:3.2

docker run -p 6379:6379 -v /zzyyuse/myredis/data:/data -v /zzyyuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

docker exec -it Redis容器id redis-cli
Voir Toi
关注
专栏目录
docker的基本概念
aaronszm的博客
02-10 1478
一、docker的基础介绍 1、docker发展历史 （1）Docker 是一个开放源代码软件项目，让应用程序部署在软件货柜下的工作可以自动化进行，借此在 Linux 操作系统上，提供一个额外的软件抽象层，以及操作系统层虚拟化的自动管理机制。 Docker 利用 Linux 核心中的资源分离机制，例如 cgroups，以及 Linux 核心名字空间，来创建独立的容器。 （2）Docker 是一...
Docker学习笔记（一）:Docker的三个基本概念
Kunikida的专栏
05-24 4788
Docker 包括三个基本概念 镜像（Image）容器（Container）仓库（Repository） 理解了这三个概念，就理解了 Docker 的整个生命周期。 镜像Image Docker 镜像就是一个只读的模板。 例如：一个镜像可以包含一个完整的 ubuntu 操作系统环境，里面仅安装了 Apache 或用户需要的其它应用程序。 镜像可以用来创建 Docker 容器
Docker概念
w1316022737的博客
03-29 249
重补Docker概念 Docker是怎么工作的？ Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接收命令并管理运行在主机上的容器，容器是一个运行时环境，好比集装箱 为什么Docker比VM运行快？ ❶Docker有着比虚拟机更少的抽象层，由于Docker不需要Hypervisor实现硬件资源虚拟化，...
一、Docker的概念
guangcaiwudong的博客
07-09 2753
Docker 是一个开源的应用容器引擎，基于Go语言实现； Docker是一个开发、传输和运行应用程序的开放平台，可以将应用程序与基础架构分离，实现快速交付。
初识Docker(二)–Docker常用命令
01-07
Docker常用命令 1.查看Docker信息 # 查看docker版本 docker version # 查看docker信息 docker info # 查看docker帮助文档 docker --help 2.镜像管理 # 列出本地所有镜像 docker images # 登陆到一个Docker镜像仓库...
初识Docker和Windows-Server容器.pdf
11-13
。。。
初识Docker和Windows-Server容器.docx
07-08
。。。
初识Docker
caoyi1207的博客
12-18 218
Docker是一个开发、打包和运行应应用的开放平台，让你的应用和你的基础设置隔离开来，从而加速应用发布。使用Docker，可以让你用管理基础设施一样的方式去管理应用。 Docker解决了什么 部署一套运行运行环境会涉及到多个服务。 负载均衡nginx 数据库MySQL、MongoDB等 应用python、Java等 搜索ElasticSearch 监控Promethus、Grafana等 每个服务所依赖的环境、启动的命令 Docker架构 Docker使用的是CS架构。Docker Daemon承担着创
Docker基本概念
gcc001224的博客
07-14 1220
​​Docker 是一个开源的、轻量级的​​​容器引擎​​​，主要运行于 Linux 和 Windows，用于​​​创建、管理和编排容器​​​。Docker是一个开源的应用容器引擎，基于go语言开发并遵循了apache2.0协议开源。Docker是在Linux容器里运行应用的开源工具，是一种轻量级的“虚拟机"。Docker 的容器技术可以在一台主机上轻松为任何应用创建一个轻量级的、可移植的、自给自足的容器。Docker的Logo设计为蓝色鲸鱼,拖着许多集装箱。鲸鱼可看作为宿主机，集装箱可理解为相互隔离的容器
docker基础
qq_48107890的博客
09-01 374
docker背景 以linux而言，linux操作系统会有一个主进程pid=1派生出其他进程来控制不同服务例如: pid=2 --> python pid=3–>java pid4–>php ，三个服务可能会相互影响 使用者期望将这三个不同的服务，跑在不同的运行时环境中实现相互不影响，同时不会增加服务器成本。 延伸出能否将这三种服务分别封装起来——》KVM虚拟化技术，实现了一个操作系统模拟多个操作系统/不同的运行时环境。 随着技术发展，虚拟化技术开销较大(例如:只要运行一个python
Docker 基本概念
程序论
04-06 318
Docker 基本概念 Docker 包括三个基本概念 镜像（Image） 容器（Container） 仓库（Repository） 理解了这三个概念，就理解了 Docker 的整个生命周期。 Docker 引擎 Docker 引擎是一个包含以下主要组件的客户端服务器应用程序。 一种服务器，它是一种称为守护进程并且长时间运行的程序。 REST API用于指定程序可以用来与守护进程通...
docker概念
gqdw
05-26 2361
docker概念1.镜像Docker 镜像就是一个只读的模板。镜像可以用来创建 Docker 容器。Docker 提供了一个很简单的机制来创建镜像或者更新现有的镜像，用户甚至可以直接从其他人那里下载一个已经做好的镜像来直接使用。镜像获取，列出，搜索。[root@iZ23fm6kfevZ ~]# docker images REPOSITORY TAG
关于Docker的概念
jsenht的博客
05-30 258
Docker是一个服务容器，所谓容器就是像你的原先部署tomcat时要运行在linux上，linux也就是一个类似的容器。我们可以把自已的服务放到docker中运行，docker会帮我们做底层对操作系统库等的调用。典型的我们可以在docker容器中运行一个mysql的服务。从宏观意义上看docker容器：image镜像：镜像应该和容器是紧密相关的，这里借助oop的概念，镜像和container的关...
Docker的一些概念(1)
见证大牛成长之路的专栏
05-14 903
Docker的一些概念(1)   Docker组件与元素   Docker有三个组件和三个基本元素. 三个组件分别是: Docker Client是用户界面,它支持用户与Docker Deamon之间通信. Docker Daemon运行于主机上,处理服务请求. Docker Index是中央registry,支持拥有共有和私有访问权限的Docker容器镜像
Docker的基本概念
qq_33807380的博客
06-15 294
1.Docker是什么 Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。 2.Docker的应用场景有哪些 Web 应用的自动化打包和发布。 自动化测试和持续集成、发布。 在服务型环境中部署和调整数据库或其他的后台应用。 从头
Docker 简介
David's Notes
10-25 375
1. Docker简介 Docker是一种新的虚拟化方式。 1.1 Docker与传统虚拟化的区别 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。因此容器要比传统虚拟机更为轻便。 2. 基本概念 镜像(Image) 容器(Container) 仓库(Reposi
Java与Docker：初识Docker容器技术
"这篇文档主要介绍了Java编程语言的基本概念和特性，并引出了Docker技术作为Java应用的部署工具。Java以其面向对象、跨平台和广泛应用的特性被广大开发者所使用。而Docker则是一种轻量级的容器技术，能够简化应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值