• Docker 入门及实战

    目录

    初识 Docker

    我们写的代码会接触好几个环境：开发环境、测试环境、生产环境，为了解决不同的环境下代码的运行环境及依赖包的统一（软件跨环境迁移问题），就有了 docker。

    Docker 概念

    • Docker 是一个开源的应用容器引擎
    • Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 服务器上
    • 容器是完全使用沙箱机制，相互隔离（微服务中大量使用 docker 的原因）
    • 容器性能开销极低
    • Docker 从 17.03 版本之后分为 CE（Community Edition:社区版）和 EE（Enterprise Edition:企业版）

    总结：Docker 是一种容器技术，解决软件跨环境迁移问题

    安装 Docker

    # 1. yum 包更新到最新
yum update
# 2. 安装需要的软件包，yum-util 提供 yum-config-manager 功能，另外两个是 devicemapper 驱动依赖的
yum install -y yum-utils device-mapper-persistent-data lvm2
# 3. 设置 yum 源
yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 4. 安装 docker, 出现输入的界面都按 y
yum install -y docker-ce
# 5. 查看 docker 版本，验证是否安装成功
docker -v

    可能碰到的问题："yum-config-manager: command not found" 是因为系统默认没有安装这个命令，这个命令在 yum-utils 包里，可以通过命令yum -y install yum-utils 安装 yum-utils。

    Docker 架构

    这个图片要竖着看，也就是说架构总的分为三部分：Clients、Hosts(主机，docker的核心)、Registries(仓库，存放镜像文件)。Clients 就是 Docker 客户端，用来发送一些指令给到 daemon(docker 服务的守护进程)；Hosts 分为 local host 和 remote host，在 docker 安装完成后 docker 服务就会在后台运行（也就是图中的 daemon），docker 服务中（图中 daemon）包含了 Image 和 container；Registries 是存放镜像的仓库，分为官方仓库（Docker hub）和私有仓库（private registry，又称为私服）

    • 镜像（Image）：Docker 镜像（Image）,就相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.0.4 就包含了完整的一套 ubuntu16.0.4 最小系统的 root 文件系统。
    • 容器（Container）：镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
    • 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

    配置 Docker 镜像加速器

    官方仓库（Docker hub）服务器在国外，国内下载官方镜像有点慢，所以一般都会配置一个国内的镜像加速器：

    阿里云容器镜像加速器配置

    阿里云为每个用户都提供了一个不同的镜像加速器地址。

    登录阿里云->点击左上角菜单选择产品与服务->搜索镜像

    其它的都大同小异，只是把配置文件中的地址更换一下就可以

    Docker 命令

    由架构图可以看出，主机中的docker服务分为镜像和容器两部分，所以命令的总节就针对三部分来：docker 服务相关命令、镜像相关命令、容器相关命令

    Docker 服务相关命令

    针对架构图中的 daemon 部分

    • 启动 docker 服务

      systemctl start docker

    • 停止 docker 服务

      systemctl stop docker

    • 重启 docker 服务

      systemctl restart docker

    • 查看 docker 服务状态

      systemctl status docker

    • 开机启动 docker 服务

      systemctl enable docker

    Docker 镜像相关命令

    • 查看镜像（针对本地）

      docker images

      REPOSITORY: 仓库名称
      TAG: 版本号，下载镜像文件时需要指定版本号，默认为 latest
      IMAGE ID: 镜像 ID 对镜像删除时使用
      CREATED: 创建时间
      SIZE: 镜像大小

    • 搜索镜像（针对远程仓库）

      docker search redis
      NAME: 镜像名称
      DESCRIPTION: 描述信息
      STARS: 类似于 github 的 star
      OFFICIAL: 是否是官方, [OK]代表官方
      AUTOMATED: 是否自动流程构建的

      通过命令搜索不到镜像版本号，如何搜索镜像都有哪些版本呢？我们以 redis 为例：

      1. 进入 hub.docker.com 网站

      2. 搜索 redis 后进入这个页面，点击蓝色处，进入下一个页面，在下一个页面中就会展示版本

    • 拉取镜像（针对远程仓库）

      docker pull redis
      命令最后不跟版本号，将下载最新的版本，版本号为 lastest。指定拉取版本如下：
      docker pull redis:5.0

    • 删除镜像（针对本地）

      docker rmi [IMAGE ID]
      如果不同镜像之间 IMAGE ID 相同，我们可以通过 REPOSITORY:TAG 来删除
      docker rmi [REPOSITORY]:[TAG]

      删除所有镜像

      • docker images -q 可以罗列出所有镜像的 ID
      • docker rmi`docker images -q` 删除所有镜像

    Docker 容器相关命令

    • 查看容器

      docker ps # 查看现在正在运行的容器
docker ps -a # 查看所有容器

      CONTAINER ID: 容器ID
      IMAGE: 创建该容器的镜像
      COMMAND: 进入容器初始化执行的命令，有些镜像会有默认命令，比如：centos 的默认命令为/bin/bash
      CREATED: 创建时间
      STATUS: 是否退出，例如：Up 23 seconds，Exited (0) 5 minutes ago
      PORTS: 映射端口
      NAMES: 创建镜像时起的名字

    • 创建容器并启动容器

      docker run 参数

      • docker run -it --name=c1 centos:7 /bin/bash
        参数：

        • -i 表示容器一直运行
        • -t相当于给容器分配一个伪终端，通常与-i同事使用缩写为-it
        • --name=c1 也可以写为 --name c1 表示给容器起名字
        • cenos:7 这是在制定镜像名字和版本号
        • /bin/bash 打开一个bash交互界面

        注意：

        • -it创建的容器会立即进入容器内部，退出容器后，容器将关闭

      • docker run -id --name=c2 centos:7
        参数：

        • -d : 以守护（后台）模式运行容器。创建后不会立即进入容器，-id是-i与-d的缩写

        注意：

        • 此命令中加上/bin/bash会立即进入容器内部
        • 进入c2容器内部的命令docker exec -it c2 /bin/bash，进入后输入exit退出容器后，容器不会被关闭，这也是-it与-id的区别

      • 总结：-it创建的容器一般称为交互式容器，-id创建的容器一般称为守护式容器

    • 进入容器

      docker exec -it c2 /bin/bash
      配合【创建并启动容器】部分看

    • 启动容器

      docker start [CONTAINER ID] # 用容器id启动
docker start [NAME] # 用容器name启动

    • 停止容器

      docker stop [CONTAINER ID] # 用容器id停止
docker stop [NAME] # 用容器name停止

    • 删除容器

      docker rm [CONTAINER ID] # 用容器id删除一个容器
docker rm [NAME] # 用容器name删除一个容器
docker rm `docker ps -aq` # 删除所有容器

    • 查看容器信息

      docker inspect [CONTAINER ID] # 用容器id查看容器信息
docker inspect [NAME] # 用容器name查看容器信息

    Docker 容器的数据卷

    数据卷概念及作用

    思考：

    • Docker容器删除后，在容器中产生的数据还在么？

      ​ docker 容器中的数据没了，但是数据卷目录中的数据还在

    • Docker 容器和外部机器可以直接交换文件么？

      ​ docker 容器可以通过宿主机的数据卷与外部服务器交换文件

    • 容器之间想要进行数据交互？

      ​ 容器与容器挂载同一个数据卷就可以实现

    数据卷

    • 数据卷是宿主机中的一个目录或文件
    • 当容器目录和数据卷目录绑定后，双方的修改会立即同步
    • 一个数据卷可以被多个容器同时挂载
    • 一个容器也可以挂在多个数据卷

    数据卷作用

    • 容器数据持久化
    • 外部机器和容器之间通信
    • 容器之间数据交换

    配置数据卷

    • 创建启动容器时，使用 -v 参数设置数据卷

      docker run ... -v 宿主机目录(文件):容器内目录(文件) ...
      注意：

      • 数据卷是对【宿主机目录(文件)】的称呼

      • 两个目录(文件)必须是绝对路径
        docker run -it --name=c1 -v /root/data1:/root/data_container centos:7 /bin/bash

      • 如果目录不存在，会自动创建

      • 可以挂在多个数据卷

        docker run -it --name=c2 
-v ~/data2:/root/data2 
-v ~/data3:/root/data3 
centos:7

      • 两个容器可以挂在同一个数据卷

        docker run -it --name=c3 -v ~/data1:/root/data centos:7
docker run -it --name=c4 -v ~/data1:/root/data centos:7

    数据卷容器概念及作用

    思考：

    • 多容器进行数据交换的方式

      1. 多个容器挂在同一个数据卷。操作比较麻烦，容器数量多时，需要每一个都配置数据卷

      2. 数据卷容器，下图中的 c3 就是数据卷容器

    数据卷容器

    • 创建一个容器，挂载在一个目录，让其他容器继承自该容器（--volumes-from）

    配置数据卷容器

    1. 创建启动 c3 数据卷容器，使用 -v 参数设置数据卷

      docker run -it --name=c3 -v /volume centos:7 /bin/bash

      注意：

      • -v /volume 这部分和之前设置数据卷不同，没有数据卷目录只有容器中挂载数据卷的目录，但是 docker 服务会在宿主机上创建一个一样的目录作为数据卷

    2. 创建启动 c1 c2 容器，使用--volumes-from参数设置数据卷

      docker run -it --name=c1 --volumes-from c3 centos:7 /bin/bash
docker run -it --name=c2 --volumes-from c3 centos:7 /bin/bash

    Docker 应用部署

    MySQL 部署

    需求

    在 Docker 容器中部署 MySQL, 并通过外部 MySQL 客户端操作 MySQL Server。

    实现步骤

    1. 搜索 MySQL 镜像

      docker search mysql

    2. 拉取 MySQL 镜像

      docker pull mysql:5.6

    3. 创建容器，设置端口映射、目录映射

      # 在 /root 目录下创建 mysql 目录用于存储 mysql 数据信息
mkdir ~/mysql
cd ~/mysql

      docker run -id

    -p 3306:3306
    --name=c_mysql
    -v $PWD/conf:/etc/mysql/conf.d
    -v $PWD/logs:/logs
    -v $PWD/data:/var/lib/mysql
    -e MYSQL_ROOT_PASSWORD=123
    -d mysql:8.0.19
    --character-set-server=utf8mb4

    
参数说明：

- **-p 3306:3306**：将容器的 3306 端口映射到宿主机的 3306 端口。冒号前面的是主机端口号,后面的是docker容器内端口号
- **-v $PWD/conf:/etc/mysql/conf.d**：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
- **-v $PWD/logs:/logs**：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
- **-v $PWD/data:/var/lib/mysql** ：将主机当前目录下的data目录挂载到容器的 /var/lib/mysql 。数据目录
- **-e MYSQL_ROOT_PASSWORD=123456：**初始化 root 用户的密码。`-e`是环境变量相关的参数

4. 进入容器，操作 MySQL

```shell
# 进入容器
docker exec –it c_mysql /bin/bash
# 在容器内部执行，进入 mysql 交互式界面
mysql -uroot -p123456
# 创建数据库
create database trunk DEFAULT CHARSET utf8mb4;

    Tomcat 部署

    1. 搜索 tomcat 镜像
    docker search tomcat
    1. 拉取 tomcat 镜像
    docker pull tomcat
    1. 创建容器，设置端口映射、目录映射
    # 在/root目录下创建tomcat目录用于存储tomcat数据信息
mkdir ~/tomcat
cd ~/tomcat

    docker run -id --name=c_tomcat 
-p 8080:8080 
-v $PWD:/usr/local/tomcat/webapps 
tomcat

    • 参数说明：

      • -p 8080:8080：将容器的8080端口映射到主机的8080端口

        -v $PWD:/usr/local/tomcat/webapps：将主机中当前目录挂载到容器的webapps

    1. 使用外部机器访问 tomcat

    Nginx 部署

    1. 搜索 nginx 镜像
    docker search nginx
    1. 拉取 nginx 镜像
    docker pull nginx
    1. 创建容器，设置端口映射、目录映射
    # 在/root目录下创建nginx目录用于存储nginx数据信息
mkdir ~/nginx
cd ~/nginx
mkdir conf
cd conf
# 在~/nginx/conf/下创建nginx.conf文件,粘贴下面内容
vim nginx.conf

    user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log warn;
pid        /var/run/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /var/log/nginx/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    keepalive_timeout  65;

    #gzip  on;

    include /etc/nginx/conf.d/*.conf;
}

    docker run -id --name=c_nginx 
-p 80:80 
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf 
-v $PWD/logs:/var/log/nginx 
-v $PWD/html:/usr/share/nginx/html 
nginx
    • 注意：
      • 执行这条命令是当前目录位置必须是 ~/nginx
    • 参数说明：
      • -p 80:80：将容器的 80端口映射到宿主机的 80 端口。
      • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的 /conf/nginx.conf 挂载到容器的 :/etc/nginx/nginx.conf。配置目录
      • -v $PWD/logs:/var/log/nginx：将主机当前目录下的 logs 目录挂载到容器的/var/log/nginx。日志目录

    1. 使用外部机器访问 nginx

    Redis 部署

    1. 搜索 redis 镜像
    docker search redis
    1. 拉取 redis 镜像
    docker pull redis:5.0
    1. 创建容器，设置端口映射
    docker run -id --name=c_redis -p 6379:6379 redis:5.0
    1. 使用 windows redis 客户端连接虚拟机中的 docker 服务中的 redis 服务
    redis-cli.exe -h 192.168.149.135 -p 6379

    Dockerfile

    Docker 镜像原理

    思考：

    • docker 镜像的本质？
      • 是一个分层的文件系统
    • docker 中一个 centos 镜像为什么只有 200MB，而一个 centos 操作系统的 iso 文件要几个G？
      • Centos 的 ios 镜像文件包含 bootfs 和 rootfs，而 docker 的 centos 镜像复用了操作系统的 bootfs, 只有 rootfs 和其他镜像层
    • docker 中一个 tomcat 镜像为什么有 500MB，而一个 tomcat 安装包只有 70 多 MB？
      • 由于 docker 中镜像是分层的，tomcat 虽然只有 70 多 MB，但它需要依赖于父镜像和基础镜像，所有整个对外暴漏的 tomcat 镜像大小 500 多 MB

    操作系统组成部分：

    • 进程调度子系统
    • 进程通信子系统
    • 内存管理子系统
    • 设备管理子系统
    • 文件管理子系统
    • 网络通信子系统
    • 作业控制子系统

    Linux 文件系统由 bootfs 和 rootfs 两部分组成（ps: fs 表示 file system）

    • bootfs: 包含 bootloader（引导加载程序）和 kernel（内核）
    • rootfs: root 文件系统，包含的就是典型 Linux 系统中的 /dev，/proc，/bin，/etc等标准目录和文件
    • 不同的 Linux 发行版，bootfs 基本一样，而 rootfs 不同，比如 ubuntu，centos 等

    原理

    • docker 镜像是由特殊的文件系统叠加而成
    • 最底端是 bootfs，并使用宿主机的 bootfs
    • 第二层是 root 文件系统 rootfs，称为 base image
    • 然后再往上可以叠加其他的镜像文件
    • 统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供一个统一的视角，这样就隐藏了多层的存在，在用户角度看来，只存在一个文件系统
    • 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像称为基础镜像
    • 当从一个镜像启动容器时，Docker 会在最顶层加载一个读写文件系统作为容器

    Docker 镜像制作

    1. 容器转为镜像

      • 将修改好的容器转换为镜像

        docker commit 容器id 镜像名称:版本号

      • 将镜像文件压缩为压缩包，方便传输

        docker save -o 压缩文件名 镜像名称:版本号

      • 其他人拿到压缩文件，进行解压缩

        docker load -i 压缩文件名

      注意：

      • 这种方式生成的新的镜像中，不会包含之前的挂载目录，但是出挂在目录外的更新都会带到新的镜像中

    2. dockerfile

    Dockerfile 概念及使用

    • dockerfile 是一个文本文件
    • 包含了一条条指令
    • 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
    • 对于开发人员：可以为开发团队提供一个完全一致的开发环境
    • 对于测试人员：可以直接拿开发时所构建的镜像或者通过 Dockerfile 文件构建一个新的镜像开始工作
    • 对于运维人员：在部署时，可以实现应用的无缝移植

    Dockerfile 关键字

    关键字 作用 备注
    FROM 指定父镜像 指定dockerfile基于那个image构建
    MAINTAINER 作者信息 用来标明这个dockerfile谁写的
    LABEL 标签 用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
    RUN 执行命令 执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN ["command" , "param1","param2"]
    CMD 容器启动命令 提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD ["command" , "param1","param2"]
    ENTRYPOINT 入口 一般在制作一些执行就关闭的容器中会使用
    COPY 复制文件 build的时候复制文件到image中
    ADD 添加文件 build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
    ENV 环境变量 指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
    ARG 构建参数 构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
    VOLUME 定义外部可以挂载的数据卷 指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME ["目录"]
    EXPOSE 暴露端口 定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
    WORKDIR 工作目录 指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
    USER 指定执行用户 指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
    HEALTHCHECK 健康检查 指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
    ONBUILD 触发器 当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
    STOPSIGNAL 发送信号量到宿主机 该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
    SHELL 指定执行脚本的shell 指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

    案例

    1.1需求

    自定义 centos7 镜像。
    要求：1.默认登陆路径为/user；2.可以使用vim；

    1.2实现步骤：

    1. 定义父镜像：FROM centos:7
    2. 定义作者信息：MAINTAINER wuyognqiang wuyongqiang2012@163.com
    3. 执行安装 win 命令：RUN yum install -y vim
    4. 定义默认的工作目录：WORKDIR /usr
    5. 定义容器启动执行的命令：CMD /bin/bash
    6. 通过 dockerfile 构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本

    2.1需求

    定义 dockerfile，发布 springboot 项目

    2.2实现步骤

    1. 定义父镜像：FROM java:8
    2. 定义作者信息：MAINTAINER wuyognqiang wuyongqiang2012@163.com
    3. 将 jar 包添加到容器：ADD springboot.jar app.jar
    4. 定义容器启动执行的命令：CMD java-jar app.jar
    5. 通过 dockerfile 构建镜像：docker build -f dockerfile文件路径 -t 镜像名称:版本

    Docker 服务编排

    服务编排概念

    微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停，维护的工作量会很大。

    • 要从 dockerfile build image 或者去 dockerhub 拉取 image
    • 要创建多个 container
    • 要管理这些 container（启动停止删除）

    服务编排：按照一定的业务规则批量管理容器

    Docker Compose 概述

    Docker Compose 是一个编排多容器分布式部署的工具，提供命令集管理容器化应用的完整开发周期，包括服务构建，启动和停止。使用步骤：

    1. 利用 Dockerfile 定义运行环境镜像
    2. 使用 docker-compose.yml 定义组成应用的各服务
    3. 运行 docker-compose up 启动应用

    安装 Docker Compose

    # Compose目前已经完全支持Linux、Mac OS和Windows，在我们安装Compose之前，需要先安装Docker。下面我 们以编译好的二进制包方式安装在Linux系统中。 
curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
# 设置文件可执行权限 
chmod +x /usr/local/bin/docker-compose
# 查看版本信息 
docker-compose -version

    卸载 Docker Compose

    # 二进制包方式安装的，删除二进制文件即可
rm /usr/local/bin/docker-compose

    使用 docker compose 编排 nginx + springboot 项目

    1. 创建docker-compose目录
    mkdir ~/docker-compose
cd ~/docker-compose
    1. 编写 docker-compose.yml 文件
    version: '3'
services:
  nginx:
   image: nginx
   ports:
    - 80:80
   links:
    - app
   volumes:
    - ./nginx/conf.d:/etc/nginx/conf.d
  app:
    image: app
    expose:
      - "8080"
    1. 创建./nginx/conf.d目录
    mkdir -p ./nginx/conf.d
    1. 在./nginx/conf.d目录下 编写itheima.conf文件
    server {
    listen 80;
    access_log off;

    location / {
        proxy_pass http://app:8080;
    }
   
}
    1. 在~/docker-compose 目录下 使用docker-compose 启动容器
    docker-compose up # 如果添加 -d 参数表示后台启动
    1. 测试访问
    http://192.168.149.135/hello

    Docker 私有仓库

    Docker 官方的 Docker hub 是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

    一、私有仓库搭建

    # 1、拉取私有仓库镜像 
docker pull registry
# 2、启动私有仓库容器 
docker run -id --name=registry -p 5000:5000 registry
# 3、打开浏览器 输入地址http://私有仓库服务器ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功
# 4、修改daemon.json   
vim /etc/docker/daemon.json    
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip 
{"insecure-registries":["私有仓库服务器ip:5000"]} 
# 5、重启docker 服务 
systemctl restart docker
docker start registry

    二、将镜像上传至私有仓库

    # 1、标记镜像为私有仓库的镜像     
docker tag centos:7 私有仓库服务器IP:5000/centos:7
 
# 2、上传标记的镜像     
docker push 私有仓库服务器IP:5000/centos:7

    三、 从私有仓库拉取镜像

    #拉取镜像 
docker pull 私有仓库服务器ip:5000/centos:7

    Docker 与传统虚拟机比较

    容器就是将软件打包成标准化单元，以用于开发、交付和部署

    • 容器镜像是轻量的、可执行的独立软件包，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置
    • 容器化软件在任何环境中都能够始终如一的运行
    • 容器赋予了软件独立性，使其免受外在环境差异的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突
  • 相关阅读:
    mysql基础学习
    Linux退出状态码
    python psutil简单示例
    linux systemctl 常用用法简介
    (转)linux进程的地址空间，核心栈，用户栈，内核线程
    (转)NAT原理与NAT穿越
    (转)蜜果私塾：http协议学习系列——协议详解篇
    (转)Windows 7下安装配置PHP+Apache+Mysql环境教程
    (转)蜜果私塾：http协议学习和总结系列 ——协议详解篇
    (转)Linux Futex的设计与实现
  • 原文地址：https://www.cnblogs.com/wuyongqiang/p/12747589.html
Copyright © 2020-2023  润新知