在本文中，我们将详细介绍Docker学习笔记_创建和使用Centos容器的各个方面，并为您提供关于创建docker容器命令的相关解答，同时，我们也将为您带来关于1.docker学习笔记之入门，dock

在本文中，我们将详细介绍Docker学习笔记_创建和使用Centos容器的各个方面，并为您提供关于创建docker容器命令的相关解答，同时，我们也将为您带来关于1.docker 学习笔记之入门，docker 在 centos7 下的安装以及基础命令的使用、CentOS 7 : Docker私有仓库搭建和使用、centos docker 篇学习笔记、CentOS学习笔记 - 6. docker安装的有用知识。

• Docker学习笔记_创建和使用Centos容器（创建docker容器命令）
• 1.docker 学习笔记之入门，docker 在 centos7 下的安装以及基础命令的使用
• CentOS 7 : Docker私有仓库搭建和使用
• centos docker 篇学习笔记
• CentOS学习笔记 - 6. docker安装

Docker学习笔记_创建和使用Centos容器（创建docker容器命令）

实验：创建和使用Centos容器

步骤：

1.搜索                                                     sudo docker search centos

2.下载镜像                                              sudo docker pull centos:7                                                  #这里下载centos 7版本

3、查看容器,获得镜像ID                          sudo docker images

4、创建和启动容器                                  sudo docker run --name=myCentos -itd centos /bin/bash

这里给创建的容器命名为myCentos

5、查看正在运行的容器，获得容器ID      sudo docker ps -s

6、进入正在运行的centos的容器             sudo docker attach [container ID]

7、退出容器

    exit

1.docker 学习笔记之入门，docker 在 centos7 下的安装以及基础命令的使用

1、更新update到最新的版本  
    yum  update
2、卸载老版本docker
    yum  remove docker  docker-common docker-selinux  docker-engine
3、安装需要的软件包
    yum install -y yum-utils  device-mapper-persistent-data lvm2
4、设置yum源
    yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
5、查看docker版本
    yum list docker-ce --showduplicates|sort -r  

6、安装docker
    yum  install  docker-ce-18.03.1.ce -y  #yum  install docker-ce-3:20.10.9-3.el8
7、启动docker
    systemctl start docker
8、加入开机自启
    systemctl enable docker

9、配置国内镜像

    vi /etc/docker/daemon.json 
    {
        "registry-mirrors": ["http://hub-mirror.c.163.com"]
    }

Docker 包括三个基本概念:
镜像（Image）
容器（Container）
仓库（Repository）

如若以上操作 中出现错误

则强制安装此版本

yum install https://download.docker.com/linux/centos/8/x86_64/stable/Packages/containerd.io-1.4.3-3.1.el8.x86_64.rpm

1.启动
 docker start 容器名
2.删除
   docker rm 容器名
3.停止所容器
  docker stop  $(docker ps -a -q)
  docker rm  $(docker ps -a -q) 

4.docker build -t 名称 .
  Usage：docker build [OPTIONS] PATH | URL | -

  OPTIONS：
  -t ，--tag list  #构建后的镜像名称
  -f， --file string #指定Dockerfiile文件位置
    示例：
     1，docker build . 
     2，docker build -t redis:v1 .
     3，docker build -t redis:v2 -f /path/Dockerfile /path

Dockerfile 快速入门指令

  1.FROM 指定基础镜像

    所谓定制镜像，那一定是以一个镜像为基础，在其上进行定制。就像我们之前运行了一个redis镜像的容器，再进行修改一样，基础镜像是必须指定的。而 FROM 就是指定基础镜像，因此一个  Dockerfile  中  FROM  是必备的指令，并且必须是第一条指令。
    在 Docker Store 上有非常多的高质量的官方镜像，有可以直接拿来使用的服务类的镜像，如nginx  、 redis  、 mongo  、 mysql  、 httpd  、 php  、 tomcat  等；如果没有找到对应服务的镜像，官方镜像中还提供了一些更为基础的操作系统镜像，
    如ubuntu  、 debian  、 centos、 alpine 等这些操作系统的软件库

  2、RUN 执行命令

    RUN  指令是用来执行命令行命令的。
    格式：
      RUN \<command\> (类似/bin/sh -cshell格式)

      RUN ["executable", "param1", "param2"] (exec格式)

    类似shell脚本风格的：
        FROM alpine
        RUN sed -i ''s/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g'' /etc/apk/repositories
        RUN apk add  gcc g++ libc-dev  wget vim  openssl-dev make  linux-headers 
        RUN mkdir -p /usr/src/redis
        RUN cd /usr/src/redis
        RUN wget -O redis-4.0.11.tar.gz  "http://download.redis.io/releases/redis-4.0.11.tar.gz"
        RUN tar -xzf redis-4.0.11.tar.gz -C /usr/src/redis
        RUN cd /usr/src/redis/redis-4.0.11 &&  make && make PREFIX=/usr/local/redis install
    之前说过，Dockerfile 中每一个指令都会建立一层， RUN  也不例外。每一个  RUN  的行为，就和刚才我们手工建立镜像的过程一样：新建立一层，在其上执行这些命令，执行结束后， commit这一层的修改，构成新的镜像。使用 Dockerfile 定制镜像
    而上面的这种写法，创建了很多层镜像。这是完全没有意义的，而且很多运行时不需要的东西，都被装进了镜像里，比如编译环境、更新的软件包等等。结果就是产生非常臃肿、非常多层的镜像，不仅仅增加了构建部署的时间，也很容易出错。 这是很多初学
    Docker 的人常犯的一个错误。Union FS是有最大层数限制的，比如 AUFS，曾经是最大不得超过 42 层，现在是不得超过 127 层。

导出容器

 导出容器可以导出一个已经创建的容器到一个文件，不管容器处于什么状态，可以使用docker export 命令。 命令格式为：docker export [-o|--output[=""]] CONTATINER 其中可以通过-o来指定导出的tar文件名，也可以直接通过重定向来实现。

另一种格式为：docker export 容器 id/name > 文件名.tar

导入容器

  导入的文件可以使用docker import 命令导入变成镜像，该命令的格式为：

   docker import [-c|--change[=[]]] [-m|--message[=MESSAGE]] file|URL|-[REPOSITORY[:YAG]]

   其中-c 选项可以在导入的同时执行对容器进行修改的Dockerfile指令（网络等修改）

另外 docker save&load 命令也可以导入一个镜像存储文件，但是跟 docker import 命令是有区别的

用 export&import 还是 save & load ？

export&import 和 save & load 是 docker 中的两组命令，我们先主要看看他们的区别：

  相对于文件大小来说，save方式导出的文件比export方式导出的文件大
  正是因为save方式保存了镜像的历史和层(layer)，使其可以层回滚，即回滚到之前的历史层，所以save方式导出的文件稍微大一些
  反观export方式，在导出过程中丢失所有的历史，导致其不可以层回滚，导出的文件会小一些
  可以通过 docker history 镜像名 看到层关系

3.2、容器网络

Docker 安装后，默认会创建下面三种网络类型

docker network ls 查看默认的网络

在启动容器时使用 --network bridge 指定网络类型

bridge：桥接网络

默认情况下启动的 Docker 容器，都是使用 bridge，Docker 安装时创建的桥接网络，每次 Docker 容器重启时，会按照顺序获取对应的 IP 地址，这个就导致重启下，Docker 的 IP 地址就变了

none：无指定网络 使用 --network=none ，docker 容器就不会分配局域网的 IP

host： 主机网络 使用 --network=host，此时，Docker 容器的网络会附属在主机上，两者是互通的。 例如，在容器中运行一个 Web 服务，监听 8080 端口，则主机的 8080 端口就会自动映射到容器中

3.3、 指定自定义网络

因为默认的网络不能制定固定的地址，所以我们将创建自定义网络，并指定网段（IP 可以理解为 4 组 8 个二进制组成的一段代码，然后右侧网段的 24 是指锁定前面 24 位，也就是说生成的 IP 会是 192.168.1.X,1-255）：192.168.1.0/24 并命名为 mynetwork，指令如下：
docker network create --subnet=192.168.1.0/24 mynetwork

使用此 docker 镜像 创建容器

代码如下：

docker run -itd --name redis-master --net mynetwork -p 6380:6379 --ip 192.168.1.2 redis 

参数说明： 具体可以参看一些文档
http://www.runoob.com/docker/docker-run-command.html 

http://www.dockerinfo.net/docker%E5%AE%B9%E5%99%A8-2

-d: 后台运行容器，并返回容器ID； -i: 以交互模式运行容器，通常与 -t 同时使用； -p: 端口映射，格式为：主机(宿主)端口:容器端口 -t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用； -V: 为容器挂载目录，比如 /usr/docker/data:/data 前者为数宿主机目录后者为容器内目录 --ip: 为容器制定一个固定的ip --net: 指定网络模式 这样，我们创建了2个容器，来一起查看下结果 docker ps -a 查看容器ip地址 docker network inspect mynetwork

docker build -t redis-test . #在文件夹中用默认的 Dockerfile 创建镜像

docker images #查看当前 docker 镜像

docker history 625dcdca8ecb #查看某个镜像的历史

docker ps -a #查看当前运行的容器

docker run -itd -p 8001:80 -v xxx1:xxx2 --name redis-master redis-test #使用镜像（redis-test）运行容器（redis-master） 宿主机 8001 端口映射到容器 80 端口 宿主机 xxx1 地址与容器 xxx2 地址共享（容器写入 xxx2 的数据同样会出现在宿主机的 xxx1 里）

docker rm 538265c49277 #移除容器

docker exec -it redis-master bash #进入容器 (如果出现：OCI runtime exec failed: exec failed: container_linux.go:348: starting container process caused "exec: \"bash\": executable file not found in $PATH": unknown ，那么就把 bash 改为 sh ：docker exec -it redis-master sh)

docker stop $(docker ps -a -q) #停止全部容器（-q 返回容器 id）

docker rm $(docker ps -a -q) #移除所有容器

docker rmi $(docker images -q) #删除所有镜像

docker export f4092a93c312 > nginx-jzy.tar #docker export 容器 id > 文件名.tar   导出容器（镜像快照）

docker import nginx-jzy.tar nginx-jzy:v2 #使用镜像快照创建镜像，创建的镜像没有 history

docker run -itd --name nginx-jzy-v2 e70d288bc4ef bash #使用上面创建的镜像创建容器，这里必须要有 bash 或者其他可以被挂载的进程

docker save a68a3617e7dd > nginx-jzy-save.tar #保存镜像

docker rmi a68a3617e7dd #删除镜像，因为上面导出容器使用的是这个镜像，所以生成了一个依赖这个镜像的镜像 删除失败了（Error response from daemon: conflict: unable to delete a68a3617e7dd (cannot be forced) - image has dependent child images）

docker image inspect --format=''{{.RepoTags}} {{.Id}} {{.Parent}}'' $(docker image ls -q --filter since=a68a3617e7dd) #找出 from 这个镜像的子镜像（[nginx-jzy:v2] sha256:e70d288bc4ef3f20015ca839653c1c1555ee7b2524e4085845348c7d990eb998）

docker rmi -f e70d288bc4ef #删除子镜像失败（Error response from daemon: conflict: unable to delete e70d288bc4ef (cannot be forced) - image is being used by running container be7eea6f8a9b）

docker stop be7eea6f8a9b #停止容器

docker rm be7eea6f8a9b #删除容器

docker rmi -f e70d288bc4ef #删除子镜像成功

docker rmi a68a3617e7dd #删除镜像成功

docker load < nginx-jzy-save.tar #读取保存的镜像文件（生成的镜像文件是有 history 的）

docker inspect imageid #查看镜像详情

 docker network ls #查看网络列表

docker network inspect id1 #查看网络 id 为 id1 的信息

docker network create --subnet=192.168.1.0/24 redis-network #新增网络连接方式（增加网段）

docker run -itd --name redis-test2 --network=redis-network --ip 192.168.1.3 -p 6381:6379 -v /usr/docker/redis/conf/:/usr/src/redis/conf/redis #根据之前的 redis 镜像生成 redis-test2 容器 使用自定义的 redis-network 网络，指定 ip（必须在网段内），指定端口映射，指定共享文件夹

iptables -t nat -L -n #查看桥接网络

1. 为什么系统镜像那么小呢？ 因为 docker 镜像在运行的时候直接使用 docker 宿主机器的 kernel，Linux 操作系统由内核空间和用户空间组成。

内核空间是 kernel，用户空间是 rootfs, 不同 Linux 发行版的区别主要是 rootfs. 比如 Ubuntu 14.04 使用 upstart 管理服务，apt 管理软件包； 而 CentOS 7 使用 systemd 和 yum。这些都是用户空间上的区别，Linux kernel 差别不大。所以 Docker 可以同时支持多种 Linux 镜像， 模拟出多种操作系统环境。容器共同使用镜像的内容（如果发生更改先复制镜像层到容器层然后再修改）

2. 镜像的文件如何存储的？

镜像文件是分层存储的，我们可以通过 docker history 命令查看到镜像的历史，也就是层

启动镜像的时候，一个新的可写层会加载到镜像的顶部。这一层通常称为 “容器层”， 之下是 “镜像层”。
容器层可以读写，容器所有发生文件变更写都发生在这一层。镜像层 read-only, 只允许读取。

Container 最上面是一个可写的容器层，以及若干只读的镜像层组成，Container 的数据就存放在这些层中，这样的分层结构最大的特性是 Copy-On-Write (写时复制):

    新数据会直接存放在最上面的 Container 层。

    修改现有的数据会先从 Image 层将数据复制到容器层，修改后的数据直接保存在 Container 层，Image 层保持不变。

3. 启动的容器会占用大量空间吗？

    创建镜像的时候，分层可以让 docker 只保存我们添加和修改的部分内容。其他内容基于 base 镜像，不需要存储，读取 base 镜像即可。如此，当我们创建多个镜像的时候，所有的镜像共享 base 部分。节省了磁盘空间

    docker 通过一个叫做 copy-on-write (CoW) 的策略来保证 base 镜像的安全性，以及更高的性能和空间利用率

    简单的说，启动容器的时候，最上层容器层是可写层，之下的都是镜像层，只读层。

    当容器需要读取文件的时候：从最上层镜像开始查找，往下找，找到文件后读取并放入内存，若已经在内存中了，直接使用。(即，同一台机器上运行的 docker 容器共享运行时相同的文件)。

    当容器需要添加文件的时候：直接在最上面的容器层可写层添加文件，不会影响镜像层。

    当容器需要修改文件的时候：从上往下层寻找文件，找到后，复制到容器可写层，然后，对容器来说，可以看到的是容器层的这个文件，看不到镜像层里的文件。容器在容器层修改这个文件。

    当容器需要删除文件的时候：从上往下层寻找文件，找到后在容器中记录删除。即，并不会真正的删除文件，而是软删除。

    综上，Docker 镜像通过分层实现了资源共享，通过 copy-on-write 实现了文件隔离。

CentOS 7 : Docker私有仓库搭建和使用

yum -y install docker
systemctl start docker systemctl enable docker

docker pull registry

iptables -I INPUT 1 -p tcp --dport 5000 -j ACCEPT

docker run -d -p 5000:5000 --privileged=true -v /opt/registry:/tmp/registry registry

OPTIONS='--insecure-registry 192.168.0.179:5000'    #CentOS 7系统
other_args='--insecure-registry 192.168.0.179:5000' #CentOS 6系统

docker pull docker.io/centos

docker tag centos 192.168.0.179:5000/centos

docker push 192.168.0.179:5000/centos

# 添加这一行
ADD_REGISTRY='--add-registry 192.168.0.179:5000'

curl -u myuser https://registry_ip:5000/v1/search
curl registry_ip:5000/v1/search

docker search registry_ip:5000/     #centos 7
docker search registry_ip:5000/library #centos 6

docker search registry_ip:5000/account/

centos docker 篇学习笔记

CentOS下安装yum：

https://www.cnblogs.com/jukaiit/p/8877975.html

Centos7 安装docker 以及常用命令：

https://www.cnblogs.com/zhaoyandev/p/9314387.html

学习视频：https://search.bilibili.com/all?keyword=docker&from_source=banner_search

docker 中文官网学习资料：  http://www.docker.org.cn/book/install/install-docker-under-ubuntu-precise-20.html

CentOS学习笔记 - 6. docker安装

什么是 docker

docker是加载镜像，把镜像变成容器再运行的管理程序。

二个部分 - 客户端和服务器

服务器运行在后台，实际干活的程序, 也有人把它叫做引擎。

客户端就是我们常用的docker命令，通过客户端，我们可以发命令告诉docker服务器该怎么干。

三大概念 - 镜像，仓库，容器

镜像是你应用程序和运行环境打包在一起的文件。

仓库就是一台服务器，可以上传和拉取镜像。

容器是启动之后的镜像实体。

通过一个镜像可以启动多个容器。

docker 安装

1. 使用 sudo 或 root 权限的用户登入终端。

2. 检查内核版本，内核版本要大于3.10。

uname -r

3. 添加 yum 仓库

vi /etc/yum.repos.d/docker.repo

添加如下内容

[dockerrepo]
name=Docker Repository
baseurl=https://yum.dockerproject.org/repo/main/centos/$releasever/
enabled=1
gpgcheck=1
gpgkey=https://yum.dockerproject.org/gpg

wq!退出保存一下

$releasever的值,这个表示当前系统的发行版本，可以通过rpm -qi centos-release命令查看
其中的Version：7 就是我们系统的版本号

$basearch是我们的系统硬件架构(CPU指令集),使用命令arch得到

4. 安装 docker

yum install -y docker-engine

5. 启动 docker

systemctl start docker.service

6. 验证是否成功

docker version

7. 注意

如果docker服务器起不来，可以更新一下

yum update

我们今天的关于Docker学习笔记_创建和使用Centos容器和创建docker容器命令的分享已经告一段落，感谢您的关注，如果您想了解更多关于1.docker 学习笔记之入门，docker 在 centos7 下的安装以及基础命令的使用、CentOS 7 : Docker私有仓库搭建和使用、centos docker 篇学习笔记、CentOS学习笔记 - 6. docker安装的相关信息，请在本站查询。