精华内容
下载资源
问答
  • 创建容器 1.新建容器 使用docker create命令新建一个容器 例如: docker@box:/home/box$ docker ps -a CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES docker@box:/home/box$ docker images REPOSITORY...

    一.创建容器

    1.新建容器

    使用 docker create命令新建一个容器

    例如:

    docker@box:/home/box$ docker ps -a
    CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES
    docker@box:/home/box$ docker images
    REPOSITORY   TAG       IMAGE ID       CREATED             SIZE
    test         01        d462dfcb371e   About an hour ago   72.8MB
    ubuntu       20.04     ba6acccedd29   4 days ago          72.8MB
    tomcat       latest    4ce9babdd885   6 days ago          680MB


    docker@box:/home/box$ docker create -it ubuntu:20.04
    4533c24246aff352107cd6465e081d23ea2e027b9876e6772e1dca346b36f95c


    docker@box:/home/box$ docker ps -a
    CONTAINER ID   IMAGE          COMMAND   CREATED          STATUS    PORTS     NAMES
    4533c24246af   ubuntu:20.04   "bash"    17 seconds ago   Created             elastic_rosalind

    2.启动容器

    使用docker start 命令来启动一个已经创建的容器

    docker@box:/home/box$ docker start 4533c24246af

    docker@box:/home/box$ docker ps -a

     使用docker restart命令来重启容器

    3.新建并启动容器

    除了创建容器后通过docker start 命令来启动,还可以直接新建并启动容器。命令为docker run

    docker@box:/home/box$ docker run ubuntu:20.04 /bin/echo 'hello world'
    hello world

    docker@box:/home/box$ docker run -it ubuntu:20.04 /bin/bash
    root@8e38f09924a8:/# pwd
    /
    root@8e38f09924a8:/# ls
    bin   dev  home  lib32  libx32  mnt  proc  run   srv  tmp  var
    boot  etc  lib   lib64  media   opt  root  sbin  sys  usr
    root@8e38f09924a8:/# exit
    exit

    4.守护态运行

    添加参数-d参数实现容器在后台以守护态(Daemonized)形式运行。

    docker@box:/home/box$ docker run -d ubuntu:20.04 /bin/bash -c "while true;do echo hello world ; sleep 1;done"
    941fd6ad41ee7f5f7802011835859264cccf9c3306890783be4e13f602883912
    docker@box:/home/box$ docker ps -a
    CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS     NAMES
    941fd6ad41ee   ubuntu:20.04   "/bin/bash -c 'while…"   15 seconds ago   Up 13 seconds             amazing_wilbur

    获取容器的输出信息,可以使用docker logs命令 

    docker logs 941fd6ad41ee

    二.终止容器

    可以使用docker stop命令终止一个运行中的容器

    首先向容器放松SIGTERM信号,等待一段超时时间(默认10秒)后,在发送SIGKILL信号来终止容器。

    docker stop 941fd6ad41ee

    注意:docker kill命令会直接发送SIGKILL信号来强行终止容器。

    此外,当docker容器中的指定应用终止时,容器也会自动终止。例如只启动一个终端的容器,用户通过exit命令或Ctrl+d来退出终端时,所创建的容器立刻终止,处于stopped状态。

    三.进入容器

    使用-d参数时,容器启动后会进入后台,用户无法看到容器的信息,也无法进行操作。这时候如果需要进入容器进行操作,有多种方式如官方的attach和exec命令,第三方的nsenter工具

    docker@box:/home/box$ docker run -itd ubuntu:20.04
    7de78b3fc9f8cc92591612f51d186f2a49016dcdd5812c4f202d9d7e8e740b67

    1.attach

    进入容器:docker attach interesting_payne

     

     当多个窗口同事用attach命令连到同一容器时,所有窗口会同步显示,当某个窗口阻塞时,其他窗口也无法执行操作了。

    2.exec

    可以在容器内直接执行任意命令,例如进入刚创建的容器中,并启动一个bash,通过指定-it参数来保持标准输入打开,并分配一个伪终端,通过exec命令对容器进行操作时最为推荐的方式。

    docker@box:/home/box$ docker exec -it 7de78b3fc9f8 /bin/bash
    root@7de78b3fc9f8:/# 

    3.nsenter

    四.删除容器

    可以使用docker rm 命令来删除处于终止或退出状态的容器

    如果要直接删除一个运行中的容器,可以添加-f参数。 

    五.导入和导出容器

    某些时候,需要将容器从一个系统迁移到另外一个系统,此时可以使用docker的导入导出功能。

    1.导出容器

    导出容器是指导出一个已经创建的容器到一个文件,不管此时这个容器是否处于运行状态,可以使用docker export命令,可以通过-o选项指定导出的tar文件名,也可以直接通过重定向来实现。

    可将导出的tar文件传输到其他机器上,通过导入命令导入到系统中,从而实现容器的迁移

    2.导入容器

    导出的容器可以通过docker import命令导入变成镜像,与docker load导入镜像十分类似。

    两者区别在于容器快照文件将丢弃所有的历史记录和元数据(即仅保存容器当时的快照状态),而镜像存储文件将保存完整记录,体积更大。此外,从容器快照文件导入时可以重新指定标签等元数据信息

    展开全文
  • Docker核心组件

    2020-12-28 20:30:06
    Docker核心组件 1. Docker架构 Docker使用客户端 - 服务器 (C/S) 架构模式,使用远程API来管理和创建Docker容器

    Docker核心组件

    1. Docker架构

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

    2. Docker核心要素

    2.1 客户端
    2.2 Docker Daemon 即 Docker 引擎
    2.3 Image 镜像
    2.4 Container 容器
    2.5 Repository 仓库 (参照Docker Hub)
    其中在使用过程中,我们要理解的核心要素为 镜像、容器和仓库。

    镜像(Image)与容器(Container)的关系,类似于面向对象编程中类(Class)与对象(Object)的关系。

    通过镜像创建容器,就如同通过类创建对象。

    2.1 镜像(Image)
    2.1.1 镜像的基本概念

    Docker镜像就是一个只读的模板,可以用来创建Docker容器。例如,一个镜像可以包括一个完整的centos操作系统环境,里面仅安装了mysql或用户需要的其他应用程序。
    (上篇文章示例中的tomcat镜像,就包含了centos操作系统环境,以及java运行环境JDK,以及tomcat,因为tomcat的运行需要JDK的支持)
    Docker提供了非常简单的机制来创建镜像或更新现有的镜像,用户甚至可以直接从其他人那里下载一个做好的镜像来直接使用。

    2.1.2 镜像的组成结构

    镜像是由许多层的文件系统叠加构成的,最下面是一个引导文件系统的bootfs,第二层是一个root文件系统rootfs,root文件系统通常是某种操作系统,比如centos、Ubuntu,在root文件系统之上又有很多层文件系统,这些文件系统叠加在一起,构成docker中的镜像;

    2.1.3 镜像的日常操作
    1. 下载镜像,比如下载redis镜像: docker pull redis:latest
      redis是查询到的镜像名称,latest是镜像的标签tag
      获得一个镜像有两种方式,一种是从官方镜像仓库下载,一种是通过dockerfile文件创建。
      如果是官方镜像,我们就不必自己用dockerfile文件构建了,除非官方没有才会自己去dockerfile文件构建;
    Tips: docker镜像拉取加速器

    通过登录阿里云ECS后台查看加速器地址
    https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

    编辑/etc/docker下的daemon.json文件,加上如下内容
    {“registry-mirrors”:[“https://你的ID.mirror.aliyuncs.com”]}

    保存退出后,重启docker服务即可

    1. 列出已下载的镜像:
      docker images 或者 docker images redis
    2. 运行镜像
      docker run -d redis 其中d表示后台运行
      然后通过 ps -ef | grep redis 可以查到redis进程
    3. 查看容器的状态
      docker ps
    4. 删除镜像
      docker rmi redis
      注意是rmi,不是rm,rm是删除容器

    2.2 容器

    2.2.1 容器的基本概念
    	容器是从镜像创建的运行实例。它可以被启动、停止、删除。
    每个容器都是相互隔离的、保证安全平台。
    可以把它看作一个简易版的Linux环境,包括root用户给权限,进程空间、
    用户空间、网络空间和运行在其中的程序。
    
    	Docker利用容器来运行应用,镜像是只读的,容器在启动的时候创建
    一层可写层作为最上层。
    
    2.2.2 容器的日常操作
    	启动容器有两种方式,一种是基于镜像新建一个容器并启动,另外一个是将在
    终止状态的容器重新启动。
    
    1. 通过镜像启动容器
      docker run -d -p 6379:6379 redis

    2. 已经停止的容器,我们可以通过docker start命令来启动
      开启容器
      docker start 容器ID或容器名称

    3. 查看运行中的容器
      docker ps

    4. 查看所有的容器
      docker ps -a

    5. 进入容器
      docker exec -it (容器ID或容器名) bash

    6. 停止容器
      docker stop 容器ID或容器名

    7. 删除容器 (删除前先停止)
      docker rm 容器ID或容器名

    8. 还可以使用
      docker inspect 容器ID或容器名 查看容器的更多信息

    9. 关闭所有容器 (q表示quiet,只显示容器ID)
      docker stop $(docker ps -q)

    10. 删除全部容器 (a表示all,所有容器信息,默认只显示正在运行的)
      docker rm $(docker ps -aq)

    11. 一条命令实现关闭并删除所有容器
      docker stop $(docker ps -q) & docker rm -f $(docker ps -aq)

      	因为docker的容器实在太轻量级了,很多时候用户都是随时删除
      和新创建容器。
      
    2.3 仓库(Repository)
    2.3.1 仓库的基本概念
    	仓库是集中存放镜像文件的场所,有时候会把仓库和仓库注册服务器
    (Registry)看作同一事物,并不严格区分。实际上,仓库注册服务器上往往
    存放着多个仓库,每个仓库中又包含了多个镜像,每个镜像有不同的标签
    tag;
    	仓库分为公开仓库(public)和私有仓库(private)两种形式;
    	
    	最大的公开仓库是 Docker Hub (https://hub.docker.com),存放了
    数量庞大镜像供用户下载。
    	当然,用户也可以在本地网络内创建一个私有仓库。
    	
    	当用户创建了自己的镜像之后就可以使用push命令将它上传到公有或私有
    仓库。这样下次在另外一台机器上使用这个镜像的时候,只需要从仓库pull
    下来即可。
    	注: Docker仓库的概念和Git类似,注册服务器也类似于GitHub这样的
    托管服务。
    
    2.3.2 仓库日常操作
    	用户可通过 docker search 命令来查找官方仓库中的镜像:
    	docker search rabbitmq
    	可以看到返回了很多包含关键字的镜像,其中包括镜像名字、描述、星级
    (表示该镜像的受欢迎程度)、是否官方创建、是否自动创建;官方的镜像说明
    是官方项目组创建和维护的,automated资源允许用户验证镜像的来源和内容。
    
    	根据是否是官方镜像,可将镜像资源分为两类;
    	一种是类似 centos 这样的基础镜像,被称为基础或根镜像。这些基础镜像
    由Docker公司创建、验证、支持、提供。这样的镜像往往使用单个单词作为
    名字;
    	还有一种类型,比如 tianon/centos 镜像,是由Docker的用户创建并维
    护的,往往带有用户名称前缀。可以通过前缀user_name/ 来指定使用某个用户
    创建的镜像。
    
    展开全文
  • Docker的三大核心组件:镜像、容器、仓库 1. 镜像 1.1 什么是镜像 1.2 镜像的两个特征 1.3 操作镜像的命令 1.3.1 获取镜像 1.3.2 查看本地镜像 1.3.3 删除本地镜像 1.3.4 镜像导出与导入 1.3.5 虚悬镜像 1.3.5 构建...

    1. 镜像

    1.1 什么是镜像

    1. 镜像就是一个Linux文件系统(Root FileSystem),里面包含运行在Linux内核的程序以及相应的数据。
      下面拓展的谈一下Linux操作系统:
    一般而言,Linux分为俩部分,*Linux内核*与*用户空间*,而真正的操作系统指的是Linux内核,
    我们常用的Centos、Ubuntu等操作系统其实是不同厂商在Linux内核基础上添加自己的软件与工具集
    (tools)形成的发布版本。
    
    1. 我们可以把镜像看做上面所说的用户空间,当Docker通过镜像创建一个容器时,就是将定义好的用户空间作为独立隔离的进程运行在宿主机的Linux内核之上。
      通过下面的示意图,我们可以更好理解Docker镜像与Linux的关系。
      在这里插入图片描述

    1.2 镜像的两个特征

    1. 分层(Layer):镜像是分层的,即一个镜像由多个中间层组成,多个镜像可以共享一个中间层,我们也可以通过在镜像上添加多一层来生成一个新的镜像。
    2. 只读(read-only):镜像在构建完成之后,便不可以再更改,而上面我们所说的添加一层构建新的镜像,这中间实际是通过创建一个临时的容器,在容器上添加或删除文件,从而生成一个新的镜像,因为容器是读写的。

    1.3 操作镜像的命令

      Docker中与镜像操作相关的命令都在docker image这条子命令下,通过docker image --help这条命令,可以看到docker image子命令的详细文档,如下:

    Usage:  docker image COMMAND
    
    Manage images
    
    Commands:
      build       Build an image from a Dockerfile(构建镜像的命令)
      history     Show the history of an image(显示镜像构建历史过程)
      import      Import the contents from a tarball to create a filesystem image(导入一个由容器导出的镜像)
      inspect     Display detailed information on one or more images(显示一个镜像的详细信息)
      load        Load an image from a tar archive or STDIN(从一个文件或标准输入流中导入镜像)
      ls          List images(查看镜像列表)
      prune       Remove unused images(删除虚悬镜像)
      pull        Pull an image or a repository from a registry(从仓库拉取镜像)
      push        Push an image or a repository to a registry(推送镜像到仓库)
      rm          Remove one or more images(删除镜像)
      save        Save one or more images to a tar archive (streamed to STDOUT by default)(保存镜像到文件)
      tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE(给镜像打标签)
    

    1.3.1 获取镜像

    在安装了Docker之后,我们本地并没有任何镜像,当然我们可以自己创建,不过更方便还是从Docker官方提供的仓库服务Docker Hub上拉取官方或第三方已经构建好的镜像。
    拉取镜像可以使用docker image pull,其格式如下:

     docker image pull [OPTIONS] NAME[:TAG|@DIGEST]
    

    当然,docker image pull有更简洁的用法,如:

     docker pull [OPTIONS] NAME[:TAG|@DIGEST]
    

    要拉取镜像,需要指定Docker Registry的URL和端口号,默认是Docker Hub,另外还需要指定仓库名和标签,仓库名和标签唯一确定一个镜像,而标签是可以省略的,如果省略,则默认使用laster作为标签名,而仓库名则由作者名和软件名组成。
    所以,在省略参数后,比如我们想拉取centos镜像,可以使用下面简单的命令从Docker Hub上拉取:

    docker pull centos
    

    1.3.2 查看本地镜像

    通过上面方法我们将镜像拉取到了本地,那要如何查看本地有哪有镜像呢?通过下面的命令我们可以查看本地的全部镜像:

    docker image ls
    

    当然Docker提供了更简洁的写法,如下:

    docker images
    

    1.3.3 删除本地镜像

    要删除一个或多个本地镜像,可以使用下面命令:

    docker image rm [option] IMAGE1,IMAGE2,...IMAGEn
    

    也可以使用更简洁的方式,如下:

    docker rmi  [option]  IMAGE1,IMAGE2,...IMAGEn
    

    我们可以根据镜像长ID,短ID、镜像摘要以及镜像名称来删除镜像,如下:

    1. 根据镜像长ID删除
     docker rmi f7302e4ab3a8
    
    1. 根据镜像短ID删除
     docker rmi f7302
    
    1. 根据镜像摘要删除
    #查询镜像摘要
    docker image ls --digests
    #删除
    docker rmi <摘要值>
    
    1. 根据镜像名删除
    docker rmi <仓库名>:<标签>
    

    我们想要清除本地全部镜像时,可以使用下面的命令,不过一般不建议使用

    docker rmi $(docker images -qa)
    

    另外,一般如果镜像已经被用来创建了容器,使用上面的命令删除会报下面错误,告诉我们该镜像已经被使用,不允许被删除。

    Error response from daemon: conflict: unable to remove repository reference "mysql:5.7" (must force) - container ccd406c07a78 is using its referenced image e1e1680ac726
    

    对于已经被用于创建容器的镜像,删除方法有两种,一种是先把容器删除,再删除镜像,另一种则只需要再删除镜像的命令种跟一个-f参数便可,如:

    $ docker rim -f f7302
    

    1.3.4 镜像导出与导入

    如果想与别人共享某个镜像,除了从镜像服务仓库中pull镜像和把镜像push到仓库之外,其实我们还可以将本地构建好的镜像直接导出并保存为文件发送给别人,如下:

    docker image save -o /test_image.tar.gz centos:latest
    

    而当你拿到别人导出的镜像文件时,可以使用docker load命令把镜像加载到本地的Docker镜像列表中,如下:

    docker load < /test_image.tar.gz
    

    1.3.5 虚悬镜像

    我们知道Docker镜像名由仓库名和标签组成,但有时候我们会看到仓库名和标签皆为<none>的镜像,我们称为这种镜像为虚悬镜像,如下图所示:
    在这里插入图片描述
    虚悬镜像一般是当我们使用docker pull拉取最新镜像时,生成了新的镜像,所以仓库名和标签都给了新的镜像,旧的镜像名和标签则被取消,成为虚悬镜像
    我们可以使用下面的命令打印所有的虚悬镜像

    docker image ls -f dangling=true
    

    一般虚悬镜像已经没有什么作用了,所以可以清理掉,下面的命令可以清除所有的虚悬镜像

     docker image prune
    

    不过,如果我们想要保留一些有用的虚悬镜像时,可以使用docker tag命令重新给镜像起个仓库名和标签:

    docker tag 621d57f27e93 "test:1.0"
    

    1.3.5 构建镜像

    上面的例子都是直接使用官方提供的镜像,其实,除了从官方仓库或其他仓库拉取别人构建好的镜像外,我们也可以构建自己的镜像,一般由以下两种构建方式:

    • 使用docker commit构建镜像
    • 使用Dockerfile构建镜像

    1.3.5.1 使用docker commit构建镜像

    使用docker commit命令,我们可以将修改过的容器重新提交为一个镜像,如:

    docker commit conntaner_id my-hello:1.0
    

    使用这种方式构建的镜像,我们称为黑箱镜像,就是一个黑箱子一样,别人并不知道我们对容器做了哪些修改和操作,所以会对其安全性有所质疑。
    所以不推荐使用这种方式构建镜像。

    1.3.5.2 使用Dockerfile构建镜像

    我们推荐编写Dockerfile来构建一种镜像,Docker Hub上的镜像都是采用这种方式构建的,采用这种方式的好处就是,我们不用把镜像分发给别人,而只是把Dockerfile和相应需要写入镜像的程序和数据发给别人,别人也能自己构建镜像,安全透明。

    • 编写一个简单的Go程序
    package main
    import "fmt"
    
    func main(){
        fmt.Println("Hello Go")
    }
    

    将Go程序编译为可执行程序,如:

    go build hello.go
    
    • 编写Dockerfile文件
    # 从一个空白的镜像开始
    FROM stratch
    ADD hello /
    # 执行
    CMD /hello
    
    • 开始构建镜像
      编写好Dockerfile文件后,需要使用docker build命令进行构建,docker build命令的格式如下:
    $ docker build [OPTIONS] PATH | URL | -
    
    # 注意最后的点(.)表示当前目录,即Dockerfile所在的目录
    $ docker build -t "hello-go:1.0" .
    

    上面只是简单演示了使用Dockerfile文件如何构建镜像,关于Dockerfile,还有许多更加深入地用法,我们之后有机再谈。

    2. 容器

    容器与镜像的关系,就如同JAVA中对象与类之间的关系。
    容器是通过镜像来创建的,所以必须先有镜像才能创建镜像,而生成的容器是一个独立于宿主机的隔离进程,并且有属于容器自己的网络和命名空间。
    我们前面介绍过,镜像是由多个中间层(Layer)组成,生成的镜像是只读的,但容器却是可读可写的,这是因为容器是再镜像上面添加一层读写层(writer/read layer)来实现的,如下图所示:
    在这里插入图片描述

    2.1 操作容器的命令

    Usage:  docker container COMMAND
    
    Manage containers
    
    Commands:
      attach      Attach local standard input, output, and error streams to a runnin                                                                                             g container
      commit      Create a new image from a container's changes(把容器保存为镜像)
      cp          Copy files/folders between a container and the local filesystem
      create      Create a new container(创建一个新的容器)
      diff        Inspect changes to files or directories on a container's filesyste                                                                                             m
      exec        Run a command in a running container(在一个运行的容器中执行命令)
      export      Export a container's filesystem as a tar archive
      inspect     Display detailed information on one or more containers
      kill        Kill one or more running containers(杀死一个或多个正在运行的容器)
      logs        Fetch the logs of a container
      ls          List containers(显示本地容器列表)
      pause       Pause all processes within one or more containers
      port        List port mappings or a specific mapping for the container
      prune       Remove all stopped containers
      rename      Rename a container(重命名容器)
      restart     Restart one or more containers(重启一个或多个容器)
      rm          Remove one or more containers(删除一个或多个容器)
      run         Run a command in a new container(运行一个新的容器)
      start       Start one or more stopped containers
      stats       Display a live stream of container(s) resource usage statistics
      stop        Stop one or more running containers(停止一个或多个容器)
      top         Display the running processes of a container
      unpause     Unpause all processes within one or more containers
      update      Update configuration of one or more containers
      wait        Block until one or more containers stop, then print their exit codes
    

    2.1.1 查询本地容器列表

    运行容器后,我们可以通过下面的命令查看本地所有容器:

    docker container ls
    # 更简洁写法
    docker ps -a
    

    上面命令执行的结果如下:

    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                               NAMES
    f4f184f5ffb9        redis:latest        "docker-entrypoint.s…"   6 seconds ago       Up 4 seconds        0.0.0.0:6379->6379/tcp              myredis
    f7d970e7d4ce        mysql:5.7           "docker-entrypoint.s…"   7 seconds ago       Up 5 seconds        0.0.0.0:3306->3306/tcp, 33060/tcp   docker-mysql
    

    有时候,我们只想查看容器的Id,可以使用下面的命令:

    docker ps -aq
    

    执行结果:

    f4f184f5ffb9
    f7d970e7d4ce
    

    2.1.2 启动容器

    启动容器由几种不同的方式,最常见的方式是使用docker run命令可以通过镜像创建一个容器。

    # /bin/bash表示运行容器后要执行的命令
    $ docker run -it centos /bin/bash
    

    docker run命令有一些比较常见的参数,比如容器是一种提供服务的守护进程,那么通常需要开放端口供外部访问,如:

    docker run -p 80:80 nginx
    

    也可以为容器指定一个名称,如:

    $ docker run -p 80:80 --name webserver nginx
    

    将容器设置为后台运行,如:

    $ docker run -p 80:80 -d --name webserver nginx
    

    另外一种则是使用docker start命令重新启动已经停止运行的容器,如:

    # container_id表示容器的id
    $ docker start container_id
    

    而对于正在运行的容器,也可以通过docker restart命令重新启动,如:

    # container_id表示容器的id
    $ docker restart container_id
    

    2.1.3 停止容器

    对于已经不需要的容器,可以使用docker stop命令停止其运行,如:

    docker stop container_id1,container_id2...
    

    批量停止容器,如:

    docker stop $(docker ps -qa)
    

    2.1.4 删除容器

    docker container rm container_id
    # 更简洁的写法
    docker rm container_id
    

    也可以像上面批量停止容器一样,我们也可以批量删除容器,如:

    $ docker rm $(docker ps -qa)
    

    当容器正在运行时,我们想要强行删除,加上-f,如:

    docker container rm -f container_id
    # 更简洁的写法
    docker rm -f container_id
    

    2.1.5 进入容器

    对于正在运行的容器,我们也可以通过docker exec命令再次进入容器,如:

    docker exec -it f4f184f5ffb9 /bin/bash
    

    需要指定容器的Id或name,上面命令我们使用的时Id。

    2.1.6 容器的三种运行模式

    概括而言,Docker容器大体上有三种运行模式,如下:

    • 运行后退出
      下面语句创建的容器,在运行后会退出
    docker run centos echo "hellowrold"
    
    • 常驻内存,就是守护进程模式
      如果容器中运行一个守护进程,则容器会一直处于运行状态,如:
    docker run -d -p 80:80 nginx
    
    • 交互式
      我们也可以在运行容器是,直接与容器交互,如:
    docker run -it centos /bin/bash
    

    3. 仓库

    仓库(Repository)是集中存储镜像的地方,这里有个概念要区分一下,那就是仓库与仓库服务器(Registry)是两回事,像我们上面说的Docker Hub,就是Docker官方提供的一个仓库服务器,不过其实有时候我们不太需要太过区分这两个概念。

    • 公共仓库
      公共仓库一般是指Docker Hub,前面我们已经多次介绍如何从Docker Hub获取镜像,除了获取镜像外,我们也可以将自己构建的镜像存放到Docker Hub,这样,别人也可以使用我们构建的镜像。
      不过要将镜像上传到Docker Hub,必须先在Docker的官方网站上注册一个账号,注册界面如下,按照要求填写必要的信息就可以了。
      在这里插入图片描述
      注册好了之后,可以在本地使用命令登录到Docker Hub
      了,过程如下:
    # 在命令行中输入
    docker login
    

    在这里插入图片描述
    在输入账号密码登录到Docker Hub之后,便可以使用docker push命令把镜像推送到Docker Hub

    $ docker push 用户名/test:1.0
    
    • 私有仓库
      有时候自己部门内部有一些镜像要共享时,如果直接导出镜像拿给别人又比较麻烦,使用Docker Hub这样的公共仓库又不是很方便,这时候我们可以自己搭建属于自己的私有仓库服务,用于存储和发布我们的镜像。
      Docker官方提供了registry这个镜像,可以用于搭建私有仓库服务,我们把镜像拉到服务器(10.20.31.210)之后,用下面命令创建该镜像的容器便可以搭建一个仓库服务,如下:
    docker run -d -p 5000:5000 --restart=always --name registry registry
    

    私有仓库访问地址:http://10.20.31.210:5000/v2/_catalog

    在这里插入图片描述
    下面我们把redis:6.2镜像推送到私有仓库,如下:

    # 从公共仓库拉取redis:6.2镜像
    docker pull redis:6.2
    # 重新打tag
    docker tag redis:6.2 10.20.31.210:5000/redis:6.2
    # 推送
    docker push 10.20.31.210:5000/redis:6.2
    

    当你第一次推送时,会报下面的错误:
    在这里插入图片描述
    解决办法:
    将私有仓库信息添加到/etc/docker/daemon.json中。

    1、配置私有仓库

    # 打开文件
    vim /etc/docker/daemon.json
    # 文件添加下面信息
    "insecure-registries": ["10.20.31.210:5000"]
    

    内容如下图所示:
    在这里插入图片描述
    2、重启docker

    sudo systemctl restart docker
    sudo systemctl daemon-reload
    

    3、再次进行推送:

    # 推送
    docker push 10.20.31.210:5000/redis:6.2
    

    在这里插入图片描述
    恭喜你,推送成功!!!

    4、访问页面查看:http://10.20.31.210:5000/v2/_catalog
    在这里插入图片描述

    4. 总结

    镜像是静态的概念,构建完成之后便不能在修改了,而容器则是一个动态的概念,使用Docker可以简单轻松地创建和删除容器,镜像与容器的关系,就如同JAVA中类与对象的关系,而仓库则是存储和分发镜像的地方。
    特别感谢原创作者:原创作者链接

    展开全文
  • 【Docker】Docker的三大核心组件

    千次阅读 2021-01-29 11:09:57
    镜像(Image)、容器(Container)、仓库(Repository)是我们常说的Docker的三大组件,接下来就让我们一起详细地探索一番吧。 一、镜像(Image) 什么是Docker镜像? 简单地理解,Docker镜像就是一个Linux的文件...

    镜像(Image)、容器(Container)、仓库(Repository)是我们常说的Docker的三大组件,接下来就让我们一起详细地探索一番吧。

    一、镜像(Image)
    什么是Docker镜像?
    简单地理解,Docker镜像就是一个Linux的文件系统(Root FileSystem),这个文件系统里面包含可以运行在Linux内核的程序以及相应的数据。

    谈到这里,我们可能需要先补充一点与Linux操作系统相关的知识:

    一般而言, Linux分为两个部分:Linux内核(Linux Kernel)与用户空间,而真正的Linux操作系统,是指Linux内核,我们常用的Ubuntu、CentOS等操作系统其实是不同厂商在Linux内核基础上添加自己的软件与工具集(tools)形成的发布版本(Linux Distribution)。

    因此,我们也可以把镜像看成是上面所说的用户空间,当Docker通过镜像创建一个容器时,就是将镜像定义好的用户空间作为独立隔离的进程运行在宿主机的Linux内核之上。

    镜像的两个特征:

    镜像是分层(Layer)的:即一个镜像可以多个中间层组成,多个镜像可以共享同一中间层,我们也可以通过在镜像添加多一层来生成一个新的镜像。

    镜像是只读的(read-only):镜像在构建完成之后,便不可以再修改,而上面我们所说的添加一层构建新的镜像,这中间实际是通过创建一个临时的容器,在容器上增加或删除文件,从而形成新的镜像,因为容器是可以动态改变的。

    通过下面的示意图,我可以更好地理解Docker镜像与Linux的关系:
    图片

    操作镜像的命令
    Docker中与镜像操作相关的命令都在docker image这条子命令下,通过docker image --help这条命令,可以看到docker image子命令的详细文档,如下:

    Usage: docker image COMMAND

    Manage images

    Commands:
    build Build an image from a Dockerfile(构建镜像的命令)
    history Show the history of an image(显示镜像构建历史过程)
    import Import the contents from a tarball to create a filesystem image(导入一个由容器导出的镜像)
    inspect Display detailed information on one or more images(显示一个镜像的详细信息)
    load Load an image from a tar archive or STDIN(从一个文件或标准输入流中导入镜像)
    ls List images(查看镜像列表)
    prune Remove unused images(删除虚悬镜像)
    pull Pull an image or a repository from a registry(从仓库拉取镜像)
    push Push an image or a repository to a registry(推送镜像到仓库)
    rm Remove one or more images(删除镜像)
    save Save one or more images to a tar archive(streamed to STDOUT by default)(保存镜像到文件)
    tag Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE(给镜像打标签)
    获取镜像
    在安装了Docker之后,我们本地并没有任何镜像,当然我们可以自己构建,不过更方便还是从Docker官方提供的仓库服务Docker Hub上拉取官方或第三方已经构建好的镜像。

    拉取镜像可以使用docker image pull,其格式如下:

    #docker pull [OPTIONS] NAME[:TAG|@DIGEST]

    要拉取镜像,需要指定Docker Registry的URL和端口号,默认是Docker Hub,另外还需要指定仓库名和标签,仓库名和标签唯一确定一个镜像,而标签是可以省略,如果省略,则默认使用latest作为标签名。

    所以,在省略了那么参数后,比如我们想拉取centos镜像,可以使用下面简单的命令从Docker Hub上拉到:

    #docker pull centos

    查看本地镜像
    通过上面的方法我们将镜像拉取到了本地,那要如何查看本地有哪些镜像呢?通过下面的命令我们可以查看本地的全部镜像:

    #docker images

    镜像导出与导入
    如果想与别人共享某个镜像,除了从镜像服务仓库中pull镜像和把镜像push到仓库上去之外,其实我们还可以将本地构建好的镜像直接导出并保存为文件发送给别人,如下:

    #docker image save /tmp/test_image.tar.gz

    而当你拿到别人导出的镜像文件,你可以使用docker load命令把镜像加载到本地的Docker镜像列表中,如下:

    #docker load < /tmp/test_image.tar.gz

    删除本地镜像
    要删除一个或多个本地的镜像,可以使用下面的命令:

    #docker rmi [option] IMAGE1,IMAGE2,…IMAGEn

    可以使用镜像的长ID、镜像短ID、镜像摘要以及镜像名称来删除镜像,如下:

    #docker rmi f7302e4ab3a8

    使用镜像的摘要也可以删除镜像,镜像的摘要可以使用下面的命令查询:

    #docker image ls --digests

    另外,一般如果镜像已经被使用来创建容器,使用上面的命令删除会报下面的错误,告诉我们该镜像已经被使用,不允许删除。

    Error response from daemon: conflict: unable to remove repository reference “mysql:5.7” (must force) - container ccd406c07a78 is using its referenced image e1e1680ac726

    对于已经被用于创建容器的镜像,删除方法有两种,一种是先把容器删除,再删除镜像,另一种则只需要在删除镜像的命令中跟一个-f参数便可。

    #docker rim -f f7302

    使用docker commit构建镜像
    上面的例子都是直接使用官方提供的镜像,其实,除了从官方仓库或其他镜像仓库拉取别人构建好的镜像外,我们也可以构建自己的镜像,一般有以下两种构建方式。

    使用docker commit命令,我们可以将修改过的容器重新提交为一个镜像,如:

    #docker commit conntaner_id name

    使用这种方式构建的镜像,我们称为黑箱镜像,就是一个黑箱子一样,别人并不知道我们对容器做了哪些修改和操作,所以会对其安全性有所质疑。
    所以不推荐使用这种方式构建镜像,下面我们介绍一种更加通用且方便的方式。

    使用Dockerfile构建镜像
    一般推荐编写Dockerfile来构建一种镜像,Docker Hub上的镜像都是采用这种方式构建的,采用这种方式的好处就是,我们不用把镜像分发给别人,而只是把Dockerfile和相应需要写入镜像的资料发给别人,别人也能自己构建镜像,安全透明。

    编写Dockerfile文件

    下面我们编写一个简单的Dockerfile文件,构建自己的第一个镜像,如下:

    从一个空白的镜像开始

    从一个空白的镜像开始

    FROM httpd
    ADD hello /

    执行

    CMD /hello
    Dockerfile常用指令

    开始构建镜像

    编写好Dockerfile文件后,需要使用docker build命令进行构建,docker build命令的格式如下:

    #docker build [OPTIONS] PATH | URL | -

    上面只是简单演示了使用Dockerfile文件如何构建镜像,关于Dockerfile,还有许多更加深入地用法,我们之后有机再谈。

    二、容器(Container)
    因为容器是通过镜像来创建的,所以必须先有镜像才能创建容器,而生成的容器是一个独立于宿主机的隔离进程,并且有属于容器自己的网络和命名空间。
    我们前面介绍过,镜像由多个中间层(layer)组成,生成的镜像是只读的,但容器却是可读可写的,这是因为容器是在镜像上面添一层读写层(writer/read layer)来实现的,如下图所示:

    操作容器的相关命令
    Usage: docker container COMMAND

    Manage containers

    Commands:
    attach Attach local standard input, output, and error streams to a runnin g container
    commit Create a new image from a container’s changes(把容器保存为镜像)
    cp Copy files/folders between a container and the local filesystem
    create Create a new container(创建一个新的容器)
    diff Inspect changes to files or directories on a container’s filesyste m
    exec Run a command in a running container(在一个运行的容器中执行命令)
    export Export a container’s filesystem as a tar archive
    inspect Display detailed information on one or more containers
    kill Kill one or more running containers(杀死一个或多个正在运行的容器)
    logs Fetch the logs of a container
    ls List containers(显示本地容器列表)
    pause Pause all processes within one or more containers
    port List port mappings or a specific mapping for the container
    prune Remove all stopped containers
    rename Rename a container(重命名容器)
    restart Restart one or more containers(重启一个或多个容器)
    rm Remove one or more containers(删除一个或多个容器)
    run Run a command in a new container(运行一个新的容器)
    start Start one or more stopped containers
    stats Display a live stream of container(s) resource usage statistics
    stop Stop one or more running containers(停止一个或多个容器)
    top Display the running processes of a container
    unpause Unpause all processes within one or more containers
    update Update configuration of one or more containers
    wait Block until one or more containers stop, then print their exit codes

    启动容器
    启动容器有几种不同的方式,最常用的方法是使用docker run命令可以通过镜像创建一个容器,如:

    /bin/bash表示运行容器后要执行的命令

    #docker run -it centos /bin/bash

    docker run命令有一些比较常用的参数,比如容器是一种提供服务的守护进程,那么通常需要开放端口供外部访问,如:

    #docker run -p 80:80 nginx

    也可以为容器指定一个名称,如:

    #docker run -p 80:80 --name zhangshan nginx

    另外一种则是使用docker start命令重新启动已经停止运行的容器,如:

    container_id表示容器的id

    #docker start container_id

    而对于正在运行的容器,也可以通过docker restart命令重新启动,如:

    container_id表示容器的id

    #docker restart container_id

    查看本地容器列表
    运行容器后,我们可以通过下面的命令查看本地所有容器:

    #docker container ls

    不过docker container ls也简洁的写法:

    #docker ps

    上面命令执行结果如下:

    CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
    f4f184f5ffb9 redis:latest “docker-entrypoint.s…” 6 seconds ago Up 4 seconds 0.0.0.0:6379->6379/tcp myredis
    f7d970e7d4ce mysql:5.7 “docker-entrypoint.s…” 7 seconds ago Up 5 seconds 0.0.0.0:3306->3306/tcp, 33060/tcp docker-mysql

    上面的命令只会显示正在运行的容器,如果要显示全部容器,包含退出执行的,可以加参数-a,如:

    #docker ps -a

    有时候,我们只想查到容器的ID,可以用下面的命令:

    #docker ps -aq

    执行结果:

    f4f184f5ffb9
    f7d970e7d4ce

    停止容器
    对于已经不需要的容器,可以使用docker stop命令停止其运行,如:

    #docker stop container_id

    批量停止容器,如:

    #docker stop $(docker ps -qa)

    容器的三种运行模式
    概括而言,Docker容器大体上有三种运行模式,如下:

    运行后退出

    下面语句创建的容器,在运行后会退出。

    #docker run centos echo “hellowrold”

    常驻内存,就是守护进程的模式

    如果容器中运行一个守护进程,则容器会一直处于运行状态,如:

    #docker run -d -p 80:80 nginx

    交互式

    我们也可以在运行容器时,直接与容器交互。

    #docker run -it centos /bin/bash

    删除容器
    #docker container rm container_id

    删除容器的命令也有简洁的写法,如下:

    #docker rm container_id

    也可以像上面批量停止容器一样,我们也可以批量删除容器,如:

    #docker rm $(docker ps -qa)

    进入容器
    对于正在运行的容器,我们也可以通过docker exec命令再次进入容器,如:

    #docker exec -it container_id /bin/bash

    需要指定容器的id或name,上面的命令我们用的是ID。

    导出容器为镜像
    #docker export -o ./image.tar.gz container_id

    将容器导出后,我们可以另外一台有安装Docker的电脑中将文件包导入成为镜像,如:

    #docker import image.tar.gz

    上面讲的是容器的概念和一些常用的命令,关于容器,还可以设置数据卷和网络空间,这些我们有机会后面再谈。

    三、仓库(Repository)
    仓库(Repository)是集中存储镜像的地方,这里有个概念要区分一下,那就是仓库与仓库服务器(Registry)是两回事,像我们上面说的Docker Hub,就是Docker官方提供的一个仓库服务器,不过其实有时候我们不太需要太过区分这两个概念。

    公共仓库
    公共仓库一般是指Docker Hub,前面我们已经多次介绍如何从Docker Hub获取镜像,除了获取镜像外,我们也可以将自己构建的镜像存放到Docker Hub,这样,别人也可以使用我们构建的镜像。
    不过要将镜像上传到Docker Hub,必须先在Docker的官方网站上注册一个账号,注册界面如下,按要求填写必要的信息就可以注册了,很简单的。

    注册好了之后,可以在本地使用命令登录到Dokcer Hub了,过程如下:

    在命令行中输入

    #docker login

    在输入账号密码登录到Docker Hub之后,便可以使用docker push命令把镜像推送到Docker Hub。

    #docker push test:1.0

    私有仓库
    有时候自己部门内部有一些镜像要共享时,如果直接导出镜像拿给别人又比较麻烦,使用像Docker Hub这样的公共仓库又不是很方便,这时候我们可以自己搭建属于自己的私有仓库服务,用于存储和分布我们的镜像。

    Docker官方提供了registry这个镜像,可以用于搭建私有仓库服务,我们把镜像拉到本地之后,用下面命令创建该镜像的容器便可以搭建一个仓库服务,如下:

    #docker run -d -p 5000:5000 --restart=always --name registry registry

    假设我们把一台IP为192.168.0.00的服务器作为仓库服务,并运行上面的语句,那么我们可以下面的语句重新构建上面的镜像,如:

    #docker build -t “192.168.0.100/hello-go:1.0” .

    然后使用下面的语句推送到自己的私有仓库服务器:

    #docker push 192.168.0.100/hello-word:1.0

    展开全文
  • 点击关注公众号,利用碎片时间学习前言先透露一下,四大组件分别是:starter, autoconfigure, CLI 以及actuator。下面我们就来详细介绍一些他们有什么用。一、Sp...
  • IoC底层核心原理 扫描组件过滤器 分析底层源码的办法 查看底层源码 的层次结构 进入它的底层源码,按F4,在右边会有显示 先看它的接口,再看它接口的实现类是怎么做的 设定组件扫描加载过滤器 名称: @ComponentScan ...
  • openstack及其核心组件

    2021-01-27 01:27:35
    openstack及其核心组件云计算概述基本特征发布模型服务类型IAAS(基础架构即服务)PAAS(平台即服务)openStack概述优势核心组件概念架构逻辑架构通信关系 了解openstack之前我们要先了解云计算这个概念 云计算 概述...
  • k8s 核心组件讲解

    2021-06-22 17:22:17
    介绍 在 k8s 集群中, master、node 会用到不同的组件,如下表 节点 组件 master kube-apiserver,kube-controller-manager,kube-scheduler,etcd node kubelet,kube-proxy,容器引擎,flannel 一、API Server API...
  • K8S核心组件介绍

    2021-08-12 00:26:52
    本篇文章主要来介绍K8S中的基础组件,以及它们所做的事情,算是一篇读书笔记吧。一、控制面 Master 节点的主要组件:1. kube-apiserver:负责对外提供集群各类资源的增删改...
  • Netty 核心组件

    2021-01-29 19:45:06
    Netty 核心组件 1. 前言 本节我们主要从整体上了解 Netty 有哪些核心组件,很多同学学习完 Netty 虽然会使用,但是只知道如何自定义 Handler 而已,根本不清楚 Netty 有哪些核心的组件。 本节的主要目的是,从...
  • 文章目录知识点WXML微信小程序组件通用属性微信小程序组件类别微信小程序组件——视图容器swiper滑块视图容器scroll-view可滚动视图容器 知识点 WXML WXML的全称是WeiXin Markup Language(微信标记语言),类似于...
  • OpenStack有哪些核心组件

    千次阅读 2020-12-29 15:24:09
    有二十多个核心组件,但是不是所有组件都像Nova、Cinder、Glance那样成熟和重要。在这里将介绍6个必备核心组件: 1.Nova是OpenStack Compute Service的项目名称,从OpenStack第一个版本Nova就集成在项目中,是最核心...
  • 程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 6 分钟。来自:blog.csdn.net/u011909918/前言先透露一下,四大组件分别是:starter, a...
  • 四、Docker的核心组件

    2021-01-25 19:09:39
    Docker 架构 Docker 使用客户端-服务器 (C/S) 架构模式,使用远程API来管理和创建Docker容器。 Docker 容器通过 Docker 镜像来创建;...Docker 的运行离不开以上核心几个组件的支持,Docker的成功也是拜这几个组件
  • Hadoop的三大核心组件

    2021-07-19 16:01:40
    Hadoop的三大核心组件分别是: HDFS(Hadoop Distribute File System):hadoop的数据存储工具。 YARN(Yet Another Resource Negotiator,另一种资源协调者):Hadoop 的资源管理器。 Hadoop MapReduce:分布式计算...
  • saas核心组件详解

    2021-05-14 12:15:37
    saas核心组件有哪些? 1、安全组件 在SaaS产品中,系统安全永远是第一位需要考虑的事情,如何保障租户数据的安全,是你首要的事情。这如同银行首选需要保障储户资金安全一样。安全组件就是统一的对SaaS产品进行安全...
  • K8S核心组件架构介绍

    2021-03-15 15:28:52
    K8S基础组件介绍Master节点组件Node节点组件其他主要组件k8s全局架构如下图 Master节点组件 Master:集群控制节点。 每个Kubernates集群至少需要一个Master节点来负责整个集群的管理和控制,基本上的控制命令都是...
  • 完整微信小程序(Java后端) 技术贴目录清单页面(必看) ...下方思维导图是小程序的组件,重点掌握核心组件和重点组件,了解扩展; 视图容器 view 视图容器(View)是小程序框架组件中最常见的基础组件
  • Spring框架核心组件,架构思想总结 一、Spring框架 1、框架简介 Spring是一个开源框架,框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 J2EE 应用程序开发提供集成的框架。Spring...
  • 一:Tomcat核心组件及应用架构详解

    千次阅读 多人点赞 2021-05-19 21:05:18
    Web 容器是什么? HTTP 的本质 HTTP 请求响应实例 Cookie 和 Session Servlet规范 Servlet 容器 Web 应用 扩展机制 一、Tomcat各组件认知 2.Tomcat 各组件及关系 二、Tomcat server.xml 配置详解 三、...
  • Spring MVC(一)五大核心组件和配置 一,五大核心组件  1.DispatcherServlet 请求入口  2.HandlerMapping 请求派发,负责请求和控制器建立一一对应的关系  3.Controller 处理器  4.ModelAndView 封装...
  • 总结tomcat的核心组件以及根目录结构1. 目录结构1.1 bin(程序文件)1.2 conf目录(配置文件)1.3 logs(日志文件) 1. 目录结构 目录 说明 bin 服务启动、停止等相关程序和文件 conf 配置文件 lib 库目录 ...
  • SpringMVC相对于前面的IOC、DI、AOP是比较简单的,Spring MVC的核心组件和大致处理流程如下图: DispatcherServlet是SpringMVC中的前端控制器(FrontController),负责接收Request并将Request转发给对应的处理组件。...
  • OpenStack八大核心组件精讲之---swift一、swift简介二、Swift架构三、Swift重要组件 一、swift简介 Swift是openstack默认的存储服务,但是在生产环境中不使用它,因为swift的机制决定了它会占用很大的CPU资源 Swift...
  • spring核心组件IOC容器的加载过程 首先spring通过applicationContext加载配置文件,通过beanDifinitionReader读取配置文件,beanDifinitionScanner扫描指定包下的所有符合要求的数据,beanDifinitionRegistry组装...
  • Netty 最高能达到接近百万的吞吐: 2 Netty核心组件 2.1 Channel 基本的 I/O 操作(bind()、connect()、read()和 write())依赖于底层网络传输所提供的原语。在基于 Java 的网络编程中,其基本的构造是类 Socket。...
  • kubernetes是谷歌开源的容器编排调度系统...master节点运行k8s的大部分核心组件,包括apiserver,scheduler,controller-manager,etcd等,k8s作为容器编排调度系统 的大部分职责都在master节点实现。 etcd etcd是k8.
  • 基础概念与组件 1.0 基础 docker docker是容器引擎之一,提供 runtime 来运行容器 是kubernetes的 CRI 接口连接的对象之一 kubernetes 是容器集群管理系统的标准工具(容器编排) 可以实现容器集群的自动化部署、...
  • scheduler把业务容器调度到最合适的节点上去 加入告诉K8S集群要启动两个副本,谁去保证有2个副本在启动,这是controller manager管理的,假如有一个挂了,它会再次启动。不管怎么样,它去保证副本数是2,副本控制器...
  • 容器编排工具主要的作用就是让容器作为集群在分布式环境中工作,适用于现在的微服务架构,各个应用以服务的形式运行在各自的容器中。在容器技术诞生初期,使用的编排工具主要有docker compose和docker swarm,前者...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 181,101
精华内容 72,440
关键字:

容器核心组件