应用部署的环境问题#

大型项目组件较多，运行环境也较为复杂，部署时会碰到一些问题：

• 依赖关系复杂，容易出现兼容性问题
• 开发、测试、生产环境有差异

例如一个项目中，部署时需要依赖于node.js、Redis、RabbitMQ、MySQL等，这些服务部署时所需要的函数库、依赖项各不相同，甚至会有冲突。给部署带来了极大的困难。

docker解决依赖兼容问题#

而Docker确巧妙的解决了这些问题，Docker是如何实现的呢？

Docker为了解决依赖的兼容问题的，采用了两个手段：

• 将应用的Libs（函数库）、Deps（依赖）、配置与应用一起打包
• 将每个应用放到一个隔离容器去运行，避免互相干扰

这样打包好的应用包中，既包含应用本身，也保护应用所需要的Libs、Deps，无需再操作系统上安装这些，自然就不存在不同应用之间的兼容问题了。

Docker解决操作系统环境差异#

要解决不同操作系统环境差异问题，必须先了解操作系统结构。以一个Ubuntu操作系统为例，结构包括：

• 计算机硬件：例如CPU、内存、磁盘等
• 系统内核：所有Linux发行版的内核都是Linux，例如CentOS、Ubuntu、Fedora等。内核可以与计算机硬件交互，对外提供内核指令，用于操作计算机硬件。
• 系统应用：操作系统本身提供的应用、函数库。这些函数库是对内核指令的封装，使用更加方便。

应用于计算机交互的流程如下：

1）应用调用操作系统应用（函数库），实现各种功能

2）系统函数库是对内核指令集的封装，会调用内核指令

3）内核指令操作计算机硬件

Docker如何解决不同系统环境的问题？

• Docker将用户程序与所需要调用的系统(比如Ubuntu)函数库一起打包
• Docker运行到不同操作系统时，直接基于打包的函数库，借助于操作系统的Linux内核来运行

Docker是一个快速交付应用、运行应用的技术，具备下列优势：

• 可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统
• 运行时利用沙箱机制形成隔离容器，各个应用互不干扰
• 启动、移除都可以通过一行命令完成，方便快捷

镜像和容器#

Docker中有几个重要的概念：

• 镜像（Image）：Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像。
• 容器（Container）：镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器进程做隔离，对外不可见。

一切应用最终都是代码组成，都是硬盘中的一个个的字节形成的文件。只有运行时，才会加载到内存，形成进程。

而镜像，就是把一个应用在硬盘上的文件、及其运行环境、部分系统函数库文件一起打包形成的文件包。这个文件包是只读的。

容器呢，就是将这些文件中编写的程序、函数加载到内存中允许，形成进程，只不过要隔离起来。因此一个镜像可以启动多次，形成多个容器进程。

DockerHub#

开源应用程序非常多，打包这些应用往往是重复的劳动。为了避免这些重复劳动，人们就会将自己打包的应用镜像，例如Redis、MySQL镜像放到网络上，共享使用，就像GitHub的代码共享一样。

• DockerHub：DockerHub是一个官方的Docker镜像的托管平台。这样的平台称为Docker Registry。
• 国内也有类似于DockerHub 的公开服务，比如 网易云镜像服务、阿里云镜像库等。

我们一方面可以将自己的镜像共享到DockerHub，另一方面也可以从DockerHub拉取镜像

Docker架构#

我们要使用Docker来操作镜像、容器，就必须要安装Docker。

Docker是一个CS架构的程序，由两部分组成：

• 服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等
• 客户端(client)：通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令。

镜像名称#

首先来看下镜像的名称组成：

• 镜名称一般分两部分组成：[repository]:[tag]。
• 在没有指定tag时，默认是latest，代表最新版本的镜像

镜像命令#

常见的镜像操作命令如图

1
docker pull nginx  # 拉取镜像
2
docker images    # 查看拉取的镜像
3

4
# docker save -o [保存的目标文件名称] [镜像名称]
5
docker save -o nginx.tar nginx:latest  # 保存镜像
6
docker rmi nginx:latest          # 删除镜像
7
docker load -i nginx.tar        # 加载镜像

容器相关命令#

• docker run：创建并运行一个容器，处于运行状态

  1
  docker run --name containerName -p 80:80 -d nginx

  • docker run ：创建并运行一个容器
  • -name : 给容器起一个名字，比如叫做mn
  • p ：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
  • d：后台运行容器
  • nginx：镜像名称，例如nginx

• docker pause：让一个运行的容器暂停

• docker unpause：让一个容器从暂停状态恢复运行

• docker stop：停止一个运行的容器

• docker start：让一个停止的容器再次运行

• docker rm：删除一个容器

• docker exec:进入容器

  1
  docker exec -it mn bash

  • docker exec ：进入容器内部，执行一个命令
  • it : 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
  • mn ：要进入的容器的名称
  • bash：进入容器后执行的命令，bash是一个linux终端交互命令

  容器内部会模拟一个独立的Linux文件系统，看起来如同一个linux服务器一样

docker run命令的常见参数

• -name：指定容器名称
• p：指定端口映射
• d：让容器后台运行

查看容器日志的命令：

• docker logs
• 添加 -f 参数可以持续查看日志

查看容器状态：

• docker ps
• docker ps -a 查看所有容器，包括已经停止的

什么是数据卷#

• *数据卷（volume）**是一个虚拟目录，指向宿主机文件系统中的某个目录。

一旦完成数据卷挂载，对容器的一切操作都会作用在数据卷对应的宿主机目录了。

这样，我们操作宿主机的/var/lib/docker/volumes/html目录，就等于操作容器内的/usr/share/nginx/html目录了

数据集操作命令#

数据卷操作的基本语法如下：

1
docker volume [COMMAND]

docker volume命令是数据卷操作，根据命令后跟随的command来确定下一步的操作：

• create 创建一个volume
• inspect 显示一个或多个volume的信息
• ls 列出所有的volume
• prune 删除未使用的volume
• rm 删除一个或多个指定的volume

创建和查看数据卷#

需求：创建一个数据卷，并查看数据卷在宿主机的目录位置

1. 创建数据卷

1
docker volume create html

1. 查看所有数据

1
docker volume ls

1. 查看数据卷详细信息卷

1
docker volume inspect html

创建的html这个数据卷关联的宿主机目录为/var/lib/docker/volumes/html/_data目录。

挂载数据卷#

我们在创建容器时，可以通过 -v 参数来挂载一个数据卷到某个容器内目录，命令格式如下：

1
docker run \\
2
  --name mn \\
3
  -v html:/root/html \\
4
  -p 8080:80
5
  nginx \\

这里的-v就是挂载数据卷的命令：

• v html:/root/htm ：把html数据卷挂载到容器内的/root/html这个目录中

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上。关联关系如下：

• 带数据卷模式：宿主机目录 —> 数据卷 ---> 容器内目录
• 直接挂载模式：宿主机目录 ---> 容器内目录

docker安装MySQL5.7：

1
# --privileged=true参数，让容器拥有真正的root权限
2
docker run --privileged=true --name mysql5.7 -p 3307:3306 \\
3
-e MYSQL_ROOT_PASSWORD=123456 -d \\
4
-v /mydata/mysql/data:/var/lib/mysql \\
5
-v /mydata/mysql/conf:/etc/mysql \\
6
-v /mydata/mysql/log:/var/log/mysql \\
7
mysql:5.7

docker run的命令中通过 -v 参数挂载文件或目录到容器中：

• v volume名称:容器内目录
• v 宿主机文件:容器内文
• v 宿主机目录:容器内目录

数据卷挂载与目录直接挂载的

• 数据卷挂载耦合度低，由docker来管理目录，但是目录较深，不好找
• 目录挂载耦合度高，需要我们自己管理目录，不过目录容易寻找查看

Environment issues for application deployment#

Large projects have many components and complex runtime environments, so deployment often runs into issues:

• Complex dependencies can easily lead to compatibility problems
• Development, testing, and production environments differ from each other

For example, a project may depend on Node.js, Redis, RabbitMQ, MySQL, and more. The libraries and dependencies required by these services differ from each other and may even conflict, which makes deployment very difficult.

How Docker Solves Dependency Compatibility Issues#

Docker happens to solve these problems very well. How does it do that?

Docker uses two methods to solve dependency compatibility issues:

• Package the application’s Libs (libraries), Deps (dependencies), and configuration together with the application
• Run each application in an isolated container to avoid interference

This packaged application bundle includes both the application itself and the Libs/Deps it requires, so you no longer need to install them separately on the operating system. Naturally, compatibility conflicts between applications are avoided.

How Docker Solves OS Environment Differences#

To solve differences between operating system environments, we first need to understand the OS structure. Taking Ubuntu as an example, it consists of:

• Computer hardware: CPU, memory, disk, etc.
• System kernel: All Linux distributions use the Linux kernel (e.g. CentOS, Ubuntu, Fedora). The kernel interacts with hardware and exposes kernel instructions for operating hardware.
• System applications: Applications and libraries provided by the OS itself. These libraries wrap kernel instructions to make them easier to use.

The interaction flow between applications and the computer is as follows:

1. Applications call OS-provided applications (libraries) to implement various functions

2. System libraries wrap the kernel instruction set and invoke kernel instructions

3. Kernel instructions operate the computer hardware

How does Docker solve cross-system environment issues?

• Docker packages the user program together with the required system libraries (for example, Ubuntu libraries)
• When Docker runs on different operating systems, it uses the packaged libraries while relying on the host OS’s Linux kernel

Docker is a technology for quickly delivering and running applications, with the following advantages:

• It can package a program, its dependencies, and runtime environment into an image that can be migrated to any Linux operating system
• At runtime it uses sandboxing to create isolated containers so applications do not interfere with each other
• Startup and removal can both be done with a single command, which is convenient and efficient

Images and Containers#

There are several important concepts in Docker:

• Image: Docker packages an application together with its dependencies, libraries, environment, configuration, and related files into an image.
• Container: The process formed when an application in an image runs is a container. Docker isolates the container process so it is not directly visible externally.

At the end of the day, applications are made of code, and code is stored as files (bytes on disk). Only when running are they loaded into memory and become processes.

An image is a read-only package formed by bundling an application’s files on disk, its runtime environment, and some system library files.

A container loads the programs/functions in those files into memory and runs them as processes, while isolating them. Therefore, one image can be started multiple times to form multiple container processes.

DockerHub#

There are many open-source applications, and packaging them repeatedly is wasted effort. To avoid this, people publish the application images they package (such as Redis and MySQL images) online for sharing, similar to code sharing on GitHub.

• DockerHub: DockerHub is the official hosting platform for Docker images. Platforms like this are called Docker Registries.
• There are also public services similar to DockerHub, such as NetEase Cloud Image Service and Alibaba Cloud Image Repository.

We can both publish our own images to DockerHub and pull images from DockerHub.

Docker Architecture#

To use Docker to manage images and containers, we must first install Docker.

Docker follows a client-server architecture and consists of two parts:

• Server: the Docker daemon, responsible for handling Docker commands and managing images/containers
• Client: sends commands to the Docker server through CLI commands or REST API. It can send commands locally or remotely.

Image Names#

Let’s first look at how image names are composed:

• Image names are generally made of two parts: [repository]:[tag].
• If no tag is specified, the default is latest, representing the latest version of the image.

Image Commands#

Common image operations are shown below.

1
docker pull nginx  # 拉取镜像
2
docker images    # 查看拉取的镜像
3

4
# docker save -o [保存的目标文件名称] [镜像名称]
5
docker save -o nginx.tar nginx:latest  # 保存镜像
6
docker rmi nginx:latest          # 删除镜像
7
docker load -i nginx.tar        # 加载镜像

Container-Related Commands#

• docker run: Create and run a container, entering the running state

  1
  docker run --name containerName -p 80:80 -d nginx

  • docker run: Create and run a container
  • --name: Give the container a name, e.g. mn
  • -p: Map host port to container port; left side is host port, right side is container port
  • -d: Run the container in the background
  • nginx: Image name, e.g. nginx

• docker pause: Pause a running container

• docker unpause: Resume a paused container

• docker stop: Stop a running container

• docker start: Start a stopped container again

• docker rm: Delete a container

• docker exec: Enter a container

  1
  docker exec -it mn bash

  • docker exec: Enter the container and execute a command
  • -it: Create a stdin/stdout terminal for interaction
  • mn: The name of the container to enter
  • bash: The command executed after entering the container; bash is a Linux shell command

  Inside the container, Docker presents an isolated Linux filesystem that looks like a standalone Linux server.

Common parameters of the docker run command

• --name: Specify the container name
• -p: Specify port mapping
• -d: Run the container in the background

Command for viewing container logs:

• docker logs
• Add the -f parameter to continuously follow logs

Commands for checking container status:

• docker ps
• docker ps -a to view all containers, including stopped ones

What Is a Volume#

• Data volume (volume): A virtual directory that points to some directory on the host filesystem.

Once volume mounting is complete, all operations on the container path affect the corresponding host directory behind the volume.

In this way, operating on /var/lib/docker/volumes/html on the host is equivalent to operating on /usr/share/nginx/html inside the container.

Volume Operation Commands#

The basic syntax for volume operations is as follows:

1
docker volume [COMMAND]

the docker volume command is used for volume operations, and the action depends on the command that follows:

• create: create a volume
• inspect: show information about one or more volumes
• ls: list all volumes
• prune: remove unused volumes
• rm: remove one or more specified volumes

Create and Inspect Volumes#

Goal: Create a volume and check its directory location on the host machine.

1. Create a volume

1
docker volume create html

1. View all volumes

1
docker volume ls

1. View detailed information for a volume

1
docker volume inspect html

The host directory corresponding to the created html volume is /var/lib/docker/volumes/html/_data.

Mounting Volumes#

When creating a container, we can use the -v parameter to mount a volume to a directory inside the container, using the following format:

1
docker run \\
2
  --name mn \\
3
  -v html:/root/html \\
4
  -p 8080:80
5
  nginx \\

Here, -v is the volume-mount option:

• -v html:/root/html: mount the html volume to /root/html inside the container

A container can mount not only volumes, but also host directories directly. The relationships are:

• Volume mode: host directory —> volume ---> container directory
• Direct bind mount mode: host directory —> container directory

Install MySQL 5.7 with Docker:

1
# --privileged=true参数，让容器拥有真正的root权限
2
docker run --privileged=true --name mysql5.7 -p 3307:3306 \\
3
-e MYSQL_ROOT_PASSWORD=123456 -d \\
4
-v /mydata/mysql/data:/var/lib/mysql \\
5
-v /mydata/mysql/conf:/etc/mysql \\
6
-v /mydata/mysql/log:/var/log/mysql \\
7
mysql:5.7

In the docker run command, the -v parameter can mount files or directories into the container:

• -v <volume-name>:<container-dir>
• -v <host-file>:<container-file>
• -v <host-dir>:<container-dir>

Volume mounts vs direct directory mounts:

• Volume mounts have lower coupling. Docker manages the directories, but the paths are deeper and harder to find.
• Directory mounts have higher coupling because we manage the directories ourselves, but the paths are easier to locate and inspect.

アプリケーションデプロイの環境問題#

大型プロジェクトは部品が多く、実行環境も複雑で、デプロイ時にいくつかの問題に直面します：

• 依存関係が複雑で、互換性の問題が発生しやすい
• 開発、テスト、本番環境に差異がある

例えばあるプロジェクトでは、デプロイ時に node.js、Redis、RabbitMQ、MySQL などの依存関係が必要となり、それらのサービスが必要とするライブラリや依存関係はそれぞれ異なり、時には衝突さえ生じます。デプロイには非常に大きな困難をもたらします。

Dockerは依存互換性の問題を解決します#

Dockerはこの問題を巧みに解決します。Dockerはどのように実現しているのでしょうか？

Dockerは依存の互換性問題を解決するため、2つの手段を採用しています：

• アプリの Libs（ライブラリ）、Deps（依存関係）、設定をアプリと一緒にパッケージ化する
• 各アプリを分離されたコンテナに入れて実行し、互いの干渉を避ける

このようにパッケージ化されたアプリパッケージには、アプリ自体だけでなく、アプリが必要とする Libs、Deps も含まれており、OS 上にそれらを再度インストールする必要はなくなるため、異なるアプリ間の互換性の問題は自然と解消されます。

DockerはOS環境差異を解決します#

OS環境の差異問題を解決するには、まずOSの構造を理解する必要があります。Ubuntu を例にとると、構造は以下のとおりです：

• コンピュータハードウェア：例えば CPU、メモリ、ディスクなど
• システムカーネル：すべての Linux ディストリビューションのカーネルは Linux であり、CentOS、Ubuntu、Fedora など。カーネルはハードウェアとやり取りし、外部にカーネル命令を提供してハードウェアを操作します
• システムアプリケーション：OS 自体が提供するアプリケーション、ライブラリ。これらのライブラリはカーネル命令のラッパーで、より使いやすくなっています

コンピュータとの対話の流れは次のとおりです：

1）アプリがOSアプリケーション（ライブラリ）を呼び出してさまざまな機能を実現する

2）システムライブラリはカーネル命令セットのラッパーで、カーネル命令を呼び出す

3）カーネル命令が計算機ハードウェアを操作する

Dockerは異なるOS環境の問題をどう解決するのか？

• Dockerはユーザーのプログラムと、呼び出す必要のあるシステム（例えば Ubuntu）のライブラリを一緒にパッケージ化する
• Dockerを別のOSで実行する場合、パッケージ化されたライブラリを直接基にして、OSのLinuxカーネルを借りて実行する

Dockerはアプリケーションを迅速に提供・実行する技術で、以下の利点を備えています：

• プログラムとその依存関係、実行環境を1つのイメージにパッケージ化でき、任意の Linux OS へ移行可能
• 実行時にはサンドボックス機構により隔離されたコンテナを作成し、各アプリは互いに干渉しません
• 起動・削除は1行のコマンドで完了でき、便利で迅速

イメージとコンテナ#

Dockerにはいくつかの重要な概念があります：

• イメージ（Image）：Dockerはアプリケーションとその依存関係、ライブラリ、環境、設定などのファイルをひとまとめにパッケージ化するイメージと呼びます。
• コンテナ（Container）：イメージの中でアプリケーションが実行されて形成されるプロセスはコンテナです。Dockerはコンテナプロセスを分離し、外部からは見えません。

すべてのアプリケーションは最終的にコードで構成され、ハードディスク上の1つずつのバイトで形成されるファイルです。実行時に初めてメモリへロードされ、プロセスを形成します。

そしてイメージは、アプリケーションのハードディスク上のファイルとその実行環境、部分的なシステムライブラリを一緒にパッケージ化して形成されるファイルパッケージです。このファイルパッケージは読み取り専用です。

コンテナは、これらのファイルに含まれるプログラムや関数をメモリへロードして実行を許可しますが、分離されます。従って1つ의イメージを複数回起動して、複数のコンテナプロセスを形成します。

Docker Hub#

オープンソースのアプリケーションは非常に多く、それらをパッケージ化する作業は繰り返しになります。この繰り返し作業を避けるため、人々は自分でパッケージ化したアプリのイメージ（例：Redis、MySQL のイメージ）をネット上に公開・共有します。GitHub のコード共有のように。

• Docker Hub：Docker Hubは公式の Docker イメージをホストするプラットフォームです。このようなプラットフォームは Docker Registry と呼ばれます。
• 国内にも Docker Hub に類似した公開サービスがあり、例えば 网易云镜像服务、Alibaba Cloud イメージライブラリ などがあります。

私たちは一方で自分のイメージを Docker Hub に共有することができ、他方で Docker Hub からイメージをプルすることもできます。

Dockerアーキテクチャ#

イメージやコンテナを操作するには、Docker をインストールしておく必要があります。

DockerはCSアーキテクチャのプログラムで、2つの部分から成り立っています：

• サーバー（server）：Docker デーモン、Docker の指示を処理し、イメージ・コンテナなどを管理します
• クライアント（client）：コマンドや RestAPI を通じて Docker サーバーへ指示を送ります。ローカルまたはリモートでサービスへ指示を送れます

イメージ名#

まずイメージ名の構成を見てみましょう：

• イメージ名は通常2つの部分で構成されます：[repository]:[tag]
• tag が未指定の場合、デフォルトは latest で、最新バージョンのイメージを表します

イメージコマンド#

一般的なイメージ操作コマンドは図のとおりです

1
docker pull nginx  # イメージを取得
2
docker images    # 取得したイメージを表示
3

4
# docker save -o [保存の対象ファイル名] [イメージ名]
5
docker save -o nginx.tar nginx:latest  # イメージを保存
6
docker rmi nginx:latest          # イメージを削除
7
docker load -i nginx.tar        # イメージを読み込む

コンテナ関連コマンド#

• docker run：1つのコンテナを作成して実行、実行状態へ

1
docker run --name containerName -p 80:80 -d nginx

• docker run：1つのコンテナを作成して実行
• -name : コンテナに名前を付ける、例えば mn
• -p ：ホストとコンテナのポートをマッピング。コロン左がホスト、右がコンテナ
• -d：バックグラウンドで実行
• nginx：イメージ名、例として nginx
• docker pause：実行中のコンテナを一時停止
• docker unpause：一時停止状態から再開
• docker stop：実行中のコンテナを停止
• docker start：停止したコンテナを再度実行
• docker rm：コンテナを削除
• docker exec: コンテナへ入る

1
docker exec -it mn bash

• docker exec：コンテナ内部に入り、コマンドを実行
• -i -t：現在入っているコンテナに標準入力・出力端末を作成し、コンテナと対話可能にする
• mn：入るコンテナの名前
• bash：コンテナ内で実行するコマンド。bashは Linux の端末対話コマンド

コンテナ内部には独立したLinuxファイルシステムが模倣され、まるで別の Linux サーバーのように見えます

docker run コマンドの一般的なパラメータ

• -name：コンテナ名を指定
• -p：ポートマッピングを指定
• -d：コンテナをバックグラウンドで実行

コンテナのログを表示するコマンド：

• docker logs
• -f を追加すると、ログを継続的に表示できます

コンテナの状態を確認する：

• docker ps
• docker ps -a は停止済みを含むすべてのコンテナを表示

データボリュームとは#

• *データボリューム（volume）**は仮想ディレクトリで、ホストマシンのファイルシステム内の特定のディレクトリを指します。

データボリュームのマウントが完了すると、コンテナへのすべての操作はデータボリュームに対応するホスト側のディレクトリに作用します。

このように、ホストの /var/lib/docker/volumes/html ディレクトリを操作すれば、コンテナ内の /usr/share/nginx/html ディレクトリを操作したことになります

データセット操作コマンド#

データボリューム操作の基本的な構文は以下のとおりです：

1
docker volume [COMMAND]

docker volume コマンドはデータボリューム操作で、続く command によって次の操作を決定します：

• create：1つのボリュームを作成
• inspect：1つまたは複数のボリュームの情報を表示
• ls：すべてのボリュームを列挙
• prune：未使用のボリュームを削除
• rm：指定した1つまたは複数のボリュームを削除

データボリュームの作成と確認#

要件：データボリュームを作成し、ホストマシン上のディレクトリ位置を確認します

1. データボリュームを作成

1
docker volume create html

1. すべてのデータを表示

1
docker volume ls

1. データボリュームの詳細情報を表示

1
docker volume inspect html

作成された html データボリュームが関連付けるホスト側のディレクトリは /var/lib/docker/volumes/html/_data ディレクトリです。

データボリュームのマウント#

コンテナを作成する際に、-v パラメータを使ってデータボリュームをコンテナ内の特定のディレクトリにマウントできます。コマンドの形式は以下のとおりです：

1
docker run \\
2
  --name mn \\
3
  -v html:/root/html \\
4
  -p 8080:80
5
  nginx \\

ここでの -v はデータボリュームをマウントするコマンドです：

• -v html:/root/html：html データボリュームをコンテナ内の /root/html ディレクトリにマウント

コンテナはデータボリュームだけでなく、ホストマシンのディレクトリにも直接マウントできます。関連付けは以下のとおりです：

• データボリュームモード：ホストディレクトリ —> データボリューム ---> コンテナ内ディレクトリ
• 直接マウントモード：ホストディレクトリ —> コンテナ内ディレクトリ

dockerはMySQL 5.7 をインストールする：

1
# --privileged=true パラメータで、コンテナに真の root 権限を付与
2
docker run --privileged=true --name mysql5.7 -p 3307:3306 \\
3
-e MYSQL_ROOT_PASSWORD=123456 -d \\
4
-v /mydata/mysql/data:/var/lib/mysql \\
5
-v /mydata/mysql/conf:/etc/mysql \\
6
-v /mydata/mysql/log:/var/log/mysql \\
7
mysql:5.7

docker run のコマンドの中で -v パラメータを使ってファイルやディレクトリをコンテナにマウントします：

• -v ボリューム名:コンテナ内ディレクトリ
• -v ホストファイル:コンテナ内のファイル
• -v ホストディレクトリ:コンテナ内ディレクトリ

データボリュームのマウントとディレクトリ直接マウントの

• データボリュームマウントは結合度が低く、Docker がディレクトリを管理しますが、ディレクトリが深くて見つけにくいです
• ディレクトリ直接マウントは結合度が高く、ディレクトリを自分で管理する必要がありますが、ディレクトリは探しやすく閲覧しやすいです