Docker 基础

Docker是一个开源的应用容器引擎，而一个容器containers其实是一个虚拟化的独立的环境，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

Docker 的局限性之一，它只能用在 64 位的操作系统上。

官方安装教程

https://docs.docker.com/engine/install/centos/

安装一些必要的系统工具

sudo yum install -y yum-utils device-mapper-persistent-data lvm2

添加软件源信息

# docker 官方源
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 阿里云源
sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

可选：启用 edge 和 test 存储库。 这些存储库包含在上面的 docker.repo 文件中，但默认情况下处于禁用状态。您可以将它们与稳定存储库一起启用。

$ sudo yum-config-manager --enable docker-ce-edge
$ sudo yum-config-manager --enable docker-ce-test

您可以通过使用 --disable 标志运行 yum-config-manager 命令来禁用边缘或测试存储库。 要重新启用它，请使用 --enable 标志。 以下命令禁用 edge 存储库:

$ sudo yum-config-manager --disable docker-ce-edge
$ sudo yum-config-manager --disable docker-ce-test

安装 Docker-ce

# 安装前可以先更新 yum 缓存：
sudo yum makecache fast
# 安装 Docker-ce
sudo yum install docker-ce

如果你想安装特定 docker-ce 版本，先列出 repo 中可用版本，然后选择安装

$ yum list docker-ce --showduplicates | sort -r
# docker-ce.x86_64       18.06.1.ce-3.el7              docker-ce-stable
# docker-ce.x86_64       18.06.1.ce-3.el7              @docker-ce-stable
# docker-ce.x86_64       18.06.0.ce-3.el7              docker-ce-stable
# docker-ce.x86_64       18.03.1.ce-1.el7.centos       docker-ce-stable
# docker-ce.x86_64       18.03.0.ce-1.el7.centos       docker-ce-stable
# docker-ce.x86_64       17.12.1.ce-1.el7.centos       docker-ce-stable
# 选择版本安装
$ sudo yum install docker-ce-<VERSION STRING>

# 选择安装 docker-ce-18.06.1.ce
$ sudo yum install docker-ce-18.06.1.ce

启动 Docker 后台服务

$ sudo systemctl start docker

通过运行 hello-world 镜像，验证是否正确安装了 docker。

$ docker run hello-world

旧版本安装

yum install docker        # CentOS 中安装
apt-get install docker-ce # Ubuntu 中安装
pacman -S docker          # Arch 中安装
emerge --ask docker       # Gentoo 中安装

#=====================
docker version      # 通过查看版本，检查安装是否成功
# Client:
#  Version:         1.12.6
#  API version:     1.24
#  Package version: docker-1.12.6-55.gitc4618fb.el7.centos.x86_64
#  Go version:      go1.8.3
#  Git commit:      c4618fb/1.12.6
#  Built:           Thu Sep 21 22:33:52 2017
#  OS/Arch:         linux/amd64
# 
# Server:
#  Version:         1.12.6
#  API version:     1.24
#  Package version: docker-1.12.6-55.gitc4618fb.el7.centos.x86_64
#  Go version:      go1.8.3
#  Git commit:      c4618fb/1.12.6
#  Built:           Thu Sep 21 22:33:52 2017
#  OS/Arch:         linux/amd64

命令介绍

$ docker --help

管理命令:
  container   管理容器
  image       管理镜像
  network     管理网络
命令：
  attach      介入到一个正在运行的容器
  build       根据 Dockerfile 构建一个镜像
  commit      根据容器的更改创建一个新的镜像
  cp          在本地文件系统与容器中复制 文件/文件夹
  create      创建一个新容器
  exec        在容器中执行一条命令
  images      列出镜像
  kill        杀死一个或多个正在运行的容器    
  logs        取得容器的日志
  pause       暂停一个或多个容器的所有进程
  ps          列出所有容器
  pull        拉取一个镜像或仓库到 registry
  push        推送一个镜像或仓库到 registry
  rename      重命名一个容器
  restart     重新启动一个或多个容器
  rm          删除一个或多个容器
  rmi         删除一个或多个镜像
  run         在一个新的容器中执行一条命令
  search      在 Docker Hub 中搜索镜像
  start       启动一个或多个已经停止运行的容器
  stats       显示一个容器的实时资源占用
  stop        停止一个或多个正在运行的容器
  tag         为镜像创建一个新的标签
  top         显示一个容器内的所有进程
  unpause     恢复一个或多个容器内所有被暂停的进程

Docker 是一个开源的容器化平台，旨在帮助开发者和运维人员更容易地创建、部署和运行应用程序。它通过将应用程序和它们的依赖打包在一起来简化这些过程。Docker 提供了一组命令来管理容器、镜像和网络。

管理命令

这些命令用于管理不同的 Docker 资源，例如容器、镜像和网络。

1. container: 管理容器，包括启动、停止、删除容器等操作。
2. image: 管理镜像，包括拉取、删除和列出镜像等操作。
3. network: 管理网络，包括创建、删除和列出网络等操作。

常用命令

1. attach: 介入到一个正在运行的容器，允许你访问容器的标准输入、输出和错误流。相当于连接到容器的控制台。

   docker attach <container_id>

2. build: 根据 Dockerfile 构建一个镜像。你可以在 Dockerfile 中定义镜像的构建步骤。

   docker build -t <image_name> <path_to_dockerfile>

3. commit: 根据容器的更改创建一个新的镜像。

   docker commit <container_id> <new_image_name>

4. cp: 在本地文件系统与容器中复制文件/文件夹。

   docker cp <container_id>:<container_path> <local_path>
   docker cp <local_path> <container_id>:<container_path>

5. create: 创建一个新容器，但不启动它。

   docker create <image_name>

6. exec: 在容器中执行一条命令。

   docker exec <container_id> <command>

7. images: 列出所有本地存储的镜像。

   docker images

8. kill: 杀死一个或多个正在运行的容器。

   docker kill <container_id>

9. logs: 取得容器的日志。

   docker logs <container_id>

10. pause: 暂停一个或多个容器的所有进程。

    docker pause <container_id>

11. ps: 列出所有容器。

    docker ps

12. pull: 从 registry 拉取一个镜像或仓库。

    docker pull <image_name>

13. push: 推送一个镜像或仓库到 registry。

    docker push <image_name>

14. rename: 重命名一个容器。

    docker rename <old_name> <new_name>

15. restart: 重新启动一个或多个容器。

    docker restart <container_id>

16. rm: 删除一个或多个容器。

    docker rm <container_id>

17. rmi: 删除一个或多个镜像。

    docker rmi <image_name>

18. run: 在一个新的容器中执行一条命令。

    docker run <image_name> <command>

19. search: 在 Docker Hub 中搜索镜像。

    docker search <image_name>

20. start: 启动一个或多个已经停止运行的容器。

    docker start <container_id>

21. stats: 显示一个容器的实时资源占用情况。

    docker stats <container_id>

22. stop: 停止一个或多个正在运行的容器。

    docker stop <container_id>

23. tag: 为镜像创建一个新的标签。

    docker tag <image_name> <new_image_name>

24. top: 显示一个容器内的所有进程。

    docker top <container_id>

25. unpause: 恢复一个或多个容器内所有被暂停的进程。

    docker unpause <container_id>

Docker 服务管理命令

1. 启动 Docker 服务

   service docker start

   • 解释: 启动 Docker 守护进程，使 Docker 服务开始运行。启动后，你可以使用 Docker 命令来管理容器和镜像。

2. 停止 Docker 服务

   service docker stop

   • 解释: 停止 Docker 守护进程，使 Docker 服务停止运行。这会停止所有正在运行的容器。

3. 查看 Docker 服务状态

   service docker status

   • 解释: 查看 Docker 服务的当前状态，显示服务是否正在运行以及相关信息。如果 Docker 服务正在运行，会显示服务的 PID（进程 ID）和运行状态。

4. 设置 Docker 服务为开机启动

   chkconfig docker on

   • 解释: 将 Docker 服务设置为系统启动时自动启动。这样，当系统重启时，Docker 服务会自动启动，无需手动启动。

示例

假设你正在一台新安装的 Linux 服务器上配置 Docker 服务，并希望在系统启动时自动启动 Docker 服务。你可以按以下步骤操作：

1. 启动 Docker 服务:

   sudo service docker start

   • 这将启动 Docker 守护进程。

2. 验证 Docker 服务已启动:

   sudo service docker status

   • 这将显示 Docker 服务的运行状态。

3. 设置 Docker 服务为开机自动启动:

   sudo chkconfig docker on

   • 这将确保 Docker 服务在每次系统启动时自动启动。

4. 验证 Docker 配置是否正确:

   • 重新启动系统，并使用 service docker status 验证 Docker 服务是否自动启动并正在运行。

补充说明

• service 命令: 用于启动、停止和查看系统服务的状态。适用于大多数基于 SysV init 的 Linux 发行版，如 CentOS 6。
• chkconfig 命令: 用于管理系统启动时哪些服务应该自动启动。适用于基于 SysV init 的系统。

在较新的基于 systemd 的系统（如 CentOS 7 及更高版本、Ubuntu 16.04 及更高版本）中，service 和 chkconfig 命令通常被 systemctl 命令替代：

• 启动 Docker 服务:

  sudo systemctl start docker

• 停止 Docker 服务:

  sudo systemctl stop docker

• 查看 Docker 服务状态:

  sudo systemctl status docker

• 设置 Docker 服务为开机自动启动:

  sudo systemctl enable docker

这些 systemctl 命令在基于 systemd 的系统中执行相同的任务。

---

镜像管理

1. 下载镜像

   docker pull centos:latest

   • 解释: 从 Docker Hub（默认的 Docker 镜像仓库）中下载最新版本的 CentOS 镜像到本地。如果不指定标签（如 :latest），默认会下载 latest 标签的镜像。

2. 查看已下载的镜像

   docker images

   • 解释: 列出所有已下载到本地的 Docker 镜像，包括镜像的仓库名（REPOSITORY）、标签（TAG）、镜像 ID、创建时间和大小。

3. 删除指定的镜像

   docker rmi [image_id]

   • 解释: 删除指定 ID 的 Docker 镜像。镜像 ID 可以通过 docker images 命令获取。

4. 删除所有无标签（dangling）的镜像

   docker rmi $(docker images | grep none | awk '{print $3}' | sort -r)

   • 解释: 删除所有无标签（dangling）的镜像。这些镜像的 REPOSITORY 和 TAG 显示为 <none>。grep none 用于筛选出无标签的镜像，awk '{print $3}' 提取镜像 ID，sort -r 逆序排列，docker rmi 删除这些镜像。

5. 使用镜像启动容器并进入命令行模式

   docker run -t -i nginx:latest /bin/bash

   • 解释: 使用 nginx:latest 镜像启动一个新的容器，并进入该容器的命令行模式。-t 选项分配一个伪终端，-i 选项保持标准输入打开。启动后，将在容器内运行 /bin/bash，使用户能够在容器内进行交互操作。输入 exit 命令可以退出容器的命令行模式。

示例操作

1. 下载 CentOS 镜像

   docker pull centos:latest

   • 下载最新的 CentOS 镜像到本地。

2. 查看本地镜像

   docker images

   • 查看本地所有下载的镜像，输出类似以下内容：

     REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
     centos              latest              5d0da3dc9764        2 weeks ago         200MB

3. 删除指定镜像

   docker rmi 5d0da3dc9764

   • 删除镜像 ID 为 5d0da3dc9764 的 CentOS 镜像。

4. 删除所有无标签的镜像

   docker rmi $(docker images | grep none | awk '{print $3}' | sort -r)

   • 删除所有无标签的镜像。

5. 使用 Nginx 镜像启动容器并进入命令行模式

   docker run -t -i nginx:latest /bin/bash

   • 使用最新的 Nginx 镜像启动一个容器并进入该容器的命令行模式。在容器内，可以执行命令进行操作，输入 exit 可以退出。

通过容器创建镜像

通过容器创建镜像有两种主要方式：从已经创建的容器中更新镜像并提交，或者使用 Dockerfile 指令来创建一个新的镜像。这里我们重点讲解如何通过已经存在的容器创建一个新的镜像。

通过已存在的容器创建一个新的镜像

你可以通过 docker commit 命令将一个容器的当前状态保存为一个新的镜像。这个方法适用于在容器中进行了一些手动操作并希望将这些更改保存为新镜像的情况。

示例命令

docker commit -m="First Docker" -a="wcjiang" a6b0a6cfdacf wcjiang/nginx:v1.2.1

命令参数说明

• -m：提交的描述信息

  • 这是对提交进行说明的文本，方便日后查看和管理镜像版本。

  -m="First Docker"

• -a：指定镜像作者

  • 这是用于标识镜像创建者的信息，便于跟踪镜像的作者。

  -a="wcjiang"

• 容器ID：容器的标识符

  • 这是源容器的ID，通过docker ps命令可以获取正在运行的容器ID。

  a6b0a6cfdacf

• 目标镜像名：新的镜像名

  • 这是新镜像的名称和标签，格式为repository:tag，可以指定镜像存放的仓库名称和标签。

  wcjiang/nginx:v1.2.1

通过Dockerfile创建镜像

1. 创建 Dockerfile 和 .dockerignore 文件

创建文件

在 Node.js 项目根目录中创建 Dockerfile 和 .dockerignore 文件。

touch Dockerfile .dockerignore

.dockerignore 文件内容

.git
node_modules
npm-debug.log

• .git：忽略版本控制目录。
• node_modules：忽略本地的 Node.js 依赖目录，因为依赖会在容器内重新安装。
• npm-debug.log：忽略 NPM 的调试日志文件。

2. Dockerfile 文件内容

# 继承官方的 Node.js 镜像，标签为 8.4
FROM node:8.4

# 将当前目录下的所有文件拷贝到镜像的 /app 目录
COPY . /app

# 设置工作目录为 /app
WORKDIR /app

# 运行 npm install 命令安装依赖
RUN npm install --registry=https://registry.npm.taobao.org

# 暴露容器的 3000 端口
EXPOSE 3000

Dockerfile 指令解释

• FROM node:8.4：指定基础镜像，这里使用官方的 Node.js 镜像，版本为 8.4。
• COPY . /app：将当前目录下的所有文件（除了 .dockerignore 文件中排除的路径）复制到镜像的 /app 目录。
• WORKDIR /app：设置工作目录为 /app，后续的命令都将在这个目录下运行。
• RUN npm install --registry=https://registry.npm.taobao.org：在 /app 目录下运行 npm install 命令，安装项目依赖，并使用淘宝的 npm 镜像源。
• EXPOSE 3000：暴露容器的 3000 端口，允许外部连接这个端口。

3. 构建镜像

使用 docker image build 命令构建镜像。

docker image build -t koa-demo .
# 或者
docker image build -t koa-demo:0.0.1 .

• -t 参数：指定镜像的名称和标签。默认标签是 latest。
• .：表示 Dockerfile 文件所在的路径为当前路径。

4. 运行容器

使用 docker run 命令运行刚刚创建的镜像。

docker run --name koa-demo-name --rm -d -p 9066:3000 koa-demo:latest
# 或者
docker run --name koa-demo-name --rm -d -p 9066:3000 koa-demo:0.0.1

运行命令参数解释

• --name koa-demo-name：指定容器的名称为 koa-demo-name。
• --rm：容器终止运行后自动删除容器文件。
• -d：在后台运行容器（detached 模式）。
• -p 9066:3000：将本地的 9066 端口映射到容器的 3000 端口。
• koa-demo:latest：指定要运行的镜像名称和标签。

总结

通过 Dockerfile 创建镜像的步骤：

1. 创建 Dockerfile 和 .dockerignore 文件。
2. 在 Dockerfile 中定义镜像构建步骤。
3. 使用 docker image build 命令构建镜像。
4. 使用 docker run 命令运行容器。

发布自己的镜像

将自定义的 Docker 镜像发布到 Docker Hub 使得其他人可以拉取和使用是常见的操作步骤。以下是详细的步骤和解释。

1. 创建 Docker Hub 账户

首先，你需要在 Docker Hub (https://hub.docker.com/) 注册一个账户。注册完成后，登录你的 Docker Hub 账户。

2. 给镜像打标签

假设你已经创建了一个名为 wcjiang/nginx:v1.2.1 的镜像。你可以给它打上新的标签 wcjiang/nginx-test:latest。

docker tag wcjiang/nginx:v1.2.1 wcjiang/nginx-test:latest

• docker tag：命令用于给镜像打标签。
• wcjiang/nginx:v1.2.1：源镜像。
• wcjiang/nginx-test:latest：目标镜像标签。

3. 登录 Docker Hub

在终端中使用 docker login 命令登录 Docker Hub。输入你的 Docker Hub 用户名和密码。

docker login

4. 上传镜像到 Docker Hub

使用 docker push 命令将镜像上传到 Docker Hub。

docker push wcjiang/nginx-test:latest

• docker push：命令用于将镜像上传到镜像仓库。
• wcjiang/nginx-test:latest：要上传的镜像。

上传成功后，你可以在 Docker Hub 的个人页面中看到该镜像。

镜像中安装软件

通常情况下，从 Docker 官方镜像库中拉取的镜像只包含基本环境。你可以在镜像中安装所需的软件。以下是一些常见的操作步骤。

使用 apt-get 在 Debian/Ubuntu 镜像中安装软件

1. 更新包索引。

apt-get update

2. 安装软件包（例如 vim）。

apt-get install vim

使用 yum 在 CentOS 镜像中安装软件

1. 进入 CentOS 镜像系统。

docker run -i -t centos:7 /bin/bash

2. 更新包索引。

yum update

3. 安装软件包（例如 vim）。

yum install vim

总结

• 发布镜像：
  1. 创建 Docker Hub 账户。
  2. 使用 docker tag 给镜像打标签。
  3. 使用 docker login 登录 Docker Hub。
  4. 使用 docker push 上传镜像。
• 在镜像中安装软件：
  • 对于 Debian/Ubuntu 系统使用 apt-get 命令。
  • 对于 CentOS 系统使用 yum 命令。

容器管理

容器管理涉及一系列操作，用于查看、启动、停止、删除和检查容器。以下是常用的 Docker 容器管理命令的详细解释：

列出容器

1. 列出本机正在运行的容器

   docker container ls

   或

   docker ps

   • 解释：列出当前所有正在运行的容器。

2. 列出本机所有容器，包括终止运行的容器

   docker container ls --all

   或

   docker ps -a

   • 解释：列出所有容器，包括运行中和已停止的容器。

启动和停止容器

3. 启动容器

   docker start [containerID/Names]

   • 解释：启动已停止的容器。[containerID/Names] 是容器的 ID 或名称。

4. 停止容器

   docker stop [containerID/Names]

   • 解释：停止正在运行的容器。[containerID/Names] 是容器的 ID 或名称。

删除容器

5. 删除容器

   docker rm [containerID/Names]

   • 解释：删除已停止的容器。[containerID/Names] 是容器的 ID 或名称。

查看日志

6. 查看容器日志

   docker logs [containerID/Names]

   • 解释：查看指定容器的日志输出。

进入容器

7. 进入容器

   docker exec -it [containerID/Names] /bin/bash

   • 解释：以交互模式进入容器的 bash shell。[containerID/Names] 是容器的 ID 或名称。

文件拷贝

8. 从正在运行的 Docker 容器里面，将文件拷贝到本机

   docker container cp [containID]:[/path/to/file] .

   • 解释：从指定容器中拷贝文件到本机当前目录。[containID] 是容器的 ID，[/path/to/file] 是容器内的文件路径。

运行命令和安装软件

9. 在 Docker 容器中运行命令

   docker run centos echo "hello world"

   • 解释：在 centos 容器中运行 echo "hello world" 命令。

10. 在 Docker 容器中安装软件

    docker run centos yum install -y wget

    • 解释：在 centos 容器中安装 wget 软件。

检查和保存容器状态

11. 检查运行中的镜像

    docker inspect centos

    • 解释：检查 centos 镜像的详细信息。

12. 保存对容器的修改

    docker commit 8bd centos

    • 解释：将 ID 为 8bd 的容器的当前状态保存为新的 centos 镜像。

13. 使用已经存在的容器创建一个镜像

    docker commit -m "n changed" my-nginx my-nginx-image

    • 解释：将 my-nginx 容器的当前状态保存为 my-nginx-image 镜像，并添加提交信息 "n changed"。

14. 获取容器的 PID 进程编号

    docker inspect -f {{.State.Pid}} 44fc0f0582d9

    • 解释：获取 ID 为 44fc0f0582d9 的容器的 PID 进程编号。

下载指定版本容器镜像

15. 下载指定版本容器镜像

    docker pull gitlab/gitlab-ce:11.2.3-ce.0

    • 解释：下载 gitlab/gitlab-ce 镜像的 11.2.3-ce.0 版本。

总结

• 查看容器：
  • docker container ls 和 docker ps：查看运行中的容器。
  • docker container ls --all 和 docker ps -a：查看所有容器。
• 启动和停止容器：
  • docker start：启动容器。
  • docker stop：停止容器。
• 删除容器：
  • docker rm：删除容器。
• 查看日志和进入容器：
  • docker logs：查看容器日志。
  • docker exec -it /bin/bash：进入容器的 bash shell。
• 文件拷贝：
  • docker container cp：从容器拷贝文件到本机。
• 运行命令和安装软件：
  • docker run：运行命令或安装软件。
• 检查和保存容器状态：
  • docker inspect：检查容器或镜像。
  • docker commit：保存容器的修改为新的镜像。
• 下载指定版本容器镜像：
  • docker pull：下载指定版本的镜像。

---

容器服务管理

管理 Docker 容器服务涉及创建、启动、停止、重启、删除和修改容器。以下是常用的容器服务管理命令的详细解释：

创建和启动容器

1. 通过nginx镜像创建容器

   docker run -itd --name my-nginx2 nginx

   • 解释：使用 nginx 镜像创建一个名为 my-nginx2 的容器，并以交互模式（-it）和后台模式（-d）运行容器。

2. 启动已有容器并添加重启策略

   docker start my-nginx --restart=always

   • 解释：启动名为 my-nginx 的容器，并设置重启策略为 always，即容器无论何时退出都会重新启动。

   重启策略有以下几种：

   • no：容器不重启。
   • on-failure：容器因退出状态非 0 时重启。
   • always：容器始终重启。

3. 启动已有容器

   docker start my-nginx

   • 解释：启动名为 my-nginx 的已存在容器。

重启和停止容器

4. 重启容器

   docker restart my-nginx

   • 解释：重启名为 my-nginx 的容器。

5. 停止运行容器

   docker stop my-nginx

   • 解释：停止名为 my-nginx 的容器。

6. 杀死运行中的容器

   docker kill my-nginx

   • 解释：立即杀死名为 my-nginx 的容器。

修改容器

7. 重命名容器

   docker rename my-nginx new-nginx

   • 解释：将名为 my-nginx 的容器重命名为 new-nginx。

8. 删除容器

   docker rm new-nginx

   • 解释：删除名为 new-nginx 的容器。

总结

• 创建容器：
  • docker run -itd --name my-nginx2 nginx：使用 nginx 镜像创建并启动一个名为 my-nginx2 的容器。
• 启动容器：
  • docker start my-nginx --restart=always：启动 my-nginx 容器并设置重启策略。
  • docker start my-nginx：启动 my-nginx 容器。
• 重启和停止容器：
  • docker restart my-nginx：重启 my-nginx 容器。
  • docker stop my-nginx：停止 my-nginx 容器。
  • docker kill my-nginx：立即杀死 my-nginx 容器。
• 修改和删除容器：
  • docker rename my-nginx new-nginx：重命名 my-nginx 容器为 new-nginx。
  • docker rm new-nginx：删除 new-nginx 容器。

---

创建和进入容器

创建一个守护状态的 Docker 容器

docker run -itd my-nginx /bin/bash

• 解释：使用my-nginx镜像创建并启动一个容器，进入交互模式（-it），并在后台运行（-d），同时执行/bin/bash命令。

查看运行中的容器

docker ps

• 解释：列出所有正在运行的容器。

• 输出：

  CONTAINER ID  IMAGE  COMMAND      CREATED          STATUS          PORTS    NAMES
  6bd0496da64f  nginx  "/bin/bash"  20 seconds ago   Up 18 seconds   80/tcp   high_shirley

使用docker exec进入容器

docker exec -it 6bd0496da64f /bin/bash

• 解释：在ID为6bd0496da64f的容器中以交互模式执行/bin/bash，进入该容器的命令行界面。

其他进入容器的方法

使用docker attach

docker attach 6bd0496da64f

• 解释：将当前终端附加到ID为6bd0496da64f的容器的主进程。不推荐，因为这会附加到容器的标准输入、输出和错误输出，不如exec灵活。

使用SSH

不建议在Docker容器中运行sshd：

• 原因：增加了不必要的复杂性和安全风险。Docker本身已经提供了多种进入容器的方法，无需额外的SSH服务。

使用nsenter

# 首先找到目标容器的PID
PID=$(docker inspect --format "{{ .State.Pid }}" <container_id>)
nsenter --target $PID --mount --uts --ipc --net --pid

• 解释：nsenter工具允许进入另一个进程的命名空间。使用Docker容器的PID进入其命名空间。
• 官方仓库：可以从官方仓库获取并安装nsenter工具。

使用docker exec

docker exec -it 6bd0496da64f /bin/bash

• 解释：在Docker 1.3及之后的版本提供的命令，允许在运行中的容器中执行命令。相比attach，exec更灵活且更安全。

总结

• 推荐使用docker exec：安全、灵活，适合在运行中的容器内执行命令或进入交互式shell。
• 不推荐docker attach：容易导致会话混乱，不如exec方便。
• 不建议使用SSH：Docker提供了更简单的进入容器的方法。
• 使用nsenter：一种底层的方式，通过进入命名空间操作容器，但一般情况下docker exec已经足够。

---

文件拷贝

Docker提供了方便的命令来在主机和容器之间复制文件或目录。

从主机复制到容器

sudo docker cp host_path containerID:container_path

• 解释：

  • host_path：本地主机上的文件或目录路径。
  • containerID：目标容器的ID或名称。
  • container_path：容器内的文件或目录路径。

• 示例：

  sudo docker cp /path/to/local/file.txt 6bd0496da64f:/path/in/container/

  这个命令会将主机上的/path/to/local/file.txt复制到ID为6bd0496da64f的容器内的/path/in/container/目录中。

从容器复制到主机

sudo docker cp containerID:container_path host_path

• 解释：

  • containerID：源容器的ID或名称。
  • container_path：容器内的文件或目录路径。
  • host_path：本地主机上的目标文件或目录路径。

• 示例：

  sudo docker cp 6bd0496da64f:/path/in/container/file.txt /path/to/local/

  这个命令会将ID为6bd0496da64f的容器内的/path/in/container/file.txt文件复制到本地主机上的/path/to/local/目录中。

注意事项

• 路径存在性：确保目标路径存在。如果路径不存在，可能会导致命令失败。
• 权限：运行命令的用户需要有适当的权限来访问源和目标路径。
• 容器状态：即使容器没有运行，docker cp命令仍然可以使用。

使用docker cp命令可以方便地在主机和容器之间传输文件，适用于需要手动调整配置或调试等场景。

Docker私有仓库搭建

私有仓库镜像registry来搭建私有仓库

1. 拉取 Docker Registry 镜像： 首先，使用 docker pull 命令从 Docker Hub 拉取 Registry 镜像的特定版本（这里使用的是 2.6.2 版本）到本地机器。命令如下：

   docker pull registry:2.6.2

   这将下载 Registry 2.6.2 版本的镜像到你的本地机器上，以便后续创建容器使用。

2. 创建并运行 Registry 容器： 接下来，使用 docker run 命令创建并运行 Registry 容器。在这个例子中，我们创建一个名为 registry 的容器，将容器的 5000 端口映射到主机的 5000 端口，同时指定容器在退出后总是自动重启。命令如下：

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

   这个命令的含义是以后台模式（-d）启动 Registry 容器，并将容器的 5000 端口映射到主机的 5000 端口，使得可以通过主机的 5000 端口访问 Registry。--restart=always 参数表示容器退出后总是自动重启。

3. 自定义存储位置： 在运行 Registry 容器时，你可以选择自定义存储位置，将容器内部的数据存储到主机的特定目录中，以确保数据的持久性和安全性。你可以使用 -v 参数来指定自定义存储位置。例如，你可以将主机上的 $HOME/_docker/registry 目录挂载到容器内部的 /var/lib/registry 目录，命令如下：

   docker run -d \
     -p 5000:5000 \
     --restart=always \
     --name registry \
     -v $HOME/_docker/registry:/var/lib/registry \
     registry:2

   这样做的好处是，即使容器被删除，你的镜像数据仍然安全地存储在主机上的指定目录中。

4. 访问 Registry： 当容器成功创建并运行后，你可以通过浏览器或命令行访问 Registry 来检查仓库是否正常运行。你可以在浏览器中访问 http://<你的主机IP>:5000/v2/（或者 http://localhost:5000/v2/），如果返回的结果是 {}，表示仓库部署成功。

5. 推送镜像到私有仓库： 最后，你可以将本地的镜像推送（push）到私有仓库中。首先，你需要拉取一个镜像到本地，然后为该镜像创建一个新的标签，最后推送到私有仓库中。具体步骤如下：

   # 拉取一个镜像到本地，这里以 nginx:1.13 为例
   docker pull nginx:1.13
   
   # 为镜像创建一个新标签，这里假设私有仓库地址为 192.168.31.69:5000
   docker tag nginx:latest 192.168.31.69:5000/test-nginx:1.13
   
   # 推送镜像到私有仓库
   docker push 192.168.31.69:5000/test-nginx:1.13

   这样就可以将镜像推送到私有仓库中了。注意，如果在推送时遇到了 HTTPS 访问错误，需要根据提示将仓库地址添加到不安全的仓库列表中，并重启 Docker 服务。

Docker 远程 API

Docker 不仅可以通过本地命令行 docker 命令进行调用，还可以通过开启远程控制 API，使用 HTTP 调用接口来进行访问，远程控制 Docker Daemon 来进行各种操作。默认情况下，Docker 的远程 API 服务未启用，因为这个服务默认不做权限认证，存在安全隐患。

启用 Docker 远程 API

步骤

1. 修改 Docker 服务配置文件： 使用编辑器（如 vim）打开 Docker 服务的配置文件，通常位于 /usr/lib/systemd/system/docker.service。

   vim /usr/lib/systemd/system/docker.service

2. 修改 ExecStart 配置项： 将 Docker 服务的启动命令修改为监听 TCP 端口 2375。

   ExecStart=/usr/bin/dockerd -H fd:// -H tcp://0.0.0.0:2375 --containerd=/run/containerd/containerd.sock

3. 重新加载 systemd 配置并重启 Docker 服务：

   systemctl daemon-reload
   systemctl restart docker

4. 检查 Docker Daemon 是否正在监听指定端口：

   netstat -nutlp | grep 2375

解释

• ExecStart：Docker 服务的启动命令，通过 -H tcp://0.0.0.0:2375 选项告诉 Docker Daemon 同时监听本地套接字和 TCP 端口 2375，以便允许远程连接。

• systemctl daemon-reload：重新加载 systemd 的配置，确保修改生效。

• systemctl restart docker：重启 Docker 服务，使修改的配置生效。

• netstat -nutlp | grep 2375：检查 Docker Daemon 是否正在监听 TCP 端口 2375。

注意事项

• 默认情况下，远程 API 服务未启用，需要手动配置启用。
• 启用远程 API 服务存在安全风险，因为默认情况下不进行权限认证。
• 建议仅在安全的网络环境中启用远程 API 服务，并在需要时配置适当的访问控制和身份验证机制。

通过以上步骤，可以在 CentOS 上启用 Docker 远程 API 服务，并通过 HTTP 接口远程控制 Docker Daemon。

docker run命令

1. -d, --detach=false：

docker run -d nginx

此命令将以后台模式运行名为 "nginx" 的容器。加上 -d 参数表示将容器放在后台运行。

2. -i, --interactive=false：

docker run -i ubuntu

此命令将以交互模式运行名为 "ubuntu" 的容器，允许用户与容器进行交互。

3. -t, --tty=false：

docker run -it ubuntu

此命令将以交互模式和分配 tty 设备的方式运行名为 "ubuntu" 的容器，允许用户与容器进行交互并分配伪终端。

4. -u, --user=""：

docker run -u 1000 ubuntu

此命令将以指定用户ID（1000）的身份运行名为 "ubuntu" 的容器。

5. -a, --attach=[]：

docker attach my-container

此命令将连接到名为 "my-container" 的容器，该容器以后台模式运行。

6. -w, --workdir=""：

docker run -w /app ubuntu

此命令将以指定工作目录 /app 运行名为 "ubuntu" 的容器。

7. -c, --cpu-shares=0：

docker run --cpu-shares=512 ubuntu

此命令将以容器 CPU 权重为 512 运行名为 "ubuntu" 的容器，用于设置容器对 CPU 资源的优先级。

8. -e, --env=[]：

docker run -e "ENV_VAR=value" ubuntu

此命令将设置名为 "ENV_VAR" 的环境变量为 "value"，并运行名为 "ubuntu" 的容器。

9. -m, --memory=""：

docker run -m 512m ubuntu

此命令将以最大内存限制为 512MB 运行名为 "ubuntu" 的容器。

10. -P, --publish-all=false：

docker run -P nginx

此命令将运行名为 "nginx" 的容器，并将容器内的所有端口映射到随机端口。

11. -p, --publish=[]：

docker run -p 8080:80 nginx

此命令将运行名为 "nginx" 的容器，并将容器内的 80 端口映射到宿主机的 8080 端口。

12. -h, --hostname=""：

docker run -h my-hostname nginx

此命令将运行名为 "nginx" 的容器，并将容器的主机名设置为 "my-hostname"。

13. -v, --volume=[]：

docker run -v /host/dir:/container/dir ubuntu

此命令将挂载主机上的 /host/dir 目录到容器内的 /container/dir 目录。

14. --volumes-from=[]：

docker run --volumes-from=my-data-container ubuntu

此命令将从名为 "my-data-container" 的数据容器挂载卷到当前容器。

15. --cap-add=[]：

docker run --cap-add=SYS_ADMIN ubuntu

此命令将向名为 "ubuntu" 的容器添加 SYS_ADMIN 权限。

16. --cap-drop=[]：

docker run --cap-drop=CHOWN ubuntu

此命令将从名为 "ubuntu" 的容器删除 CHOWN 权限。

17. --cidfile=""：

docker run --cidfile=/var/run/my-container.pid ubuntu

此命令将容器的 PID 写入 /var/run/my-container.pid 文件。

18. --cpuset=""：

docker run --cpuset=0,2 ubuntu

此命令将容器限制在 CPU 0 和 2 上运行。

19. --device=[]：

docker run --device=/dev/sda ubuntu

此命令将主机上的 /dev/sda 设备添加到名为 "ubuntu" 的容器中。

20. --dns=[]：

docker run --dns=8.8.8.8 ubuntu

此命令将容器的 DNS 服务器设置为 8.8.8.8。

21. --dns-search=[]：

docker run --dns-search=mydomain.com ubuntu

此命令将容器的 DNS 搜索域名设置为 "mydomain.com"。

22. --entrypoint=""：

docker run --entrypoint="/bin

非常简单的示例：

一个基于 CentOS 镜像的简单的 Web 服务器项目。它通过 Dockerfile 构建了一个自定义的 CentOS 镜像，该镜像安装了 Apache Web 服务器，并将 "Hello World!" 内容写入到默认的网站根目录下的 index.html 文件中。接着，通过 Docker 的基本命令，如构建镜像、运行容器等，展示了如何操作这个简单的 Web 服务器项目。

# 构建一个自定义的 CentOS 镜像
# Dockerfile
FROM centos:latest
RUN yum -y update && yum clean all
RUN yum -y install httpd && yum clean all
RUN echo "Hello World!" > /var/www/html/index.html
EXPOSE 80

# 构建镜像
docker build -t my-custom-centos .

# 显示所有镜像
docker images

# 检索镜像
docker search ubuntu

# 拉取镜像
docker pull ubuntu:latest

# 删除镜像
docker rmi ubuntu:latest

# 启动容器
docker run -d --name my-apache-container -p 8080:80 my-custom-centos

# 查看正在运行的容器
docker ps

# 停止容器
docker stop my-apache-container

# 删除容器
docker rm my-apache-container

# 查看容器统计信息
docker stats my-apache-container

# 启动容器并进入交互模式
docker run -it ubuntu:latest /bin/bash

# 设置容器开机自启（使用 --restart=always）
docker run -d --name my-container --restart=always my-image

# 查看容器日志
docker logs my-container

# 查看容器中的进程信息
docker top my-container

# 查看镜像元数据
docker inspect my-image

# 容器内外复制文件
docker cp /path/to/local/file my-container:/path/in/container
docker cp my-container:/path/in/container /path/to/local/file

# 修改容器名
docker rename old-name new-name

# 容器数据卷
# 指定路径挂载
docker run -v /host/path:/container/path my-image
# 具名挂载
docker run --name my-container -v my-volume:/container/path my-image
# 匿名挂载
docker run -v /container/path my-image

# Dockerfile 基础命令
# 构建一个自己的 CentOS 镜像
docker build -t my-centos-image .

# 查看镜像历史记录
docker history my-centos-image

有一系列实例：

Docker 实例

Docker 安装 Ubuntu

Docker 安装 Centos

Docker 安装 Nginx

Docker 安装 Node.js

Docker 安装 PHP

Docker 安装 MySQL

Docker 安装 Tomcat

Docker 安装 Python

Docker 安装 Redis

Docker 安装 MongoDB

Docker 安装 Apache