在这里，我们将给大家分享关于linux/Docker的知识，让您更了解linuxdocker常用命令的本质，同时也会涉及到如何更有效地DockerinDocker(实际上是DockeroutsideD

在这里，我们将给大家分享关于linux/Docker的知识，让您更了解linuxdocker常用命令的本质，同时也会涉及到如何更有效地Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock、Docker Windows Boot2Docker/Linux version 4.9.89-boot2docker/SSH login、Docker 入门（一）Docker 简介与安装（Linux 环境 centos）、Docker 搭建测试环境一（Linux 安装 Docke ；Docke 安装 MySQL、Tomcat、Linux、nginx 集成 连个Tomcat环境）的内容。

• linux/Docker（linuxdocker常用命令）
• Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock
• Docker Windows Boot2Docker/Linux version 4.9.89-boot2docker/SSH login
• Docker 入门（一）Docker 简介与安装（Linux 环境 centos）
• Docker 搭建测试环境一（Linux 安装 Docke ；Docke 安装 MySQL、Tomcat、Linux、nginx 集成 连个Tomcat环境）

linux/Docker（linuxdocker常用命令）

【深度探索区块链】

//查看主机上的镜像文件列表
docker images 

//从镜像仓库下载镜像文件
docker pull hyperledger/fabric-peer

//给镜像文件打标签
docker tag hyperledger/fabric-tools:x86_64-1.0.0 hyperledger/fabric-tools:latest

//从镜像中启动容器
docker run -it --name cli ubuntu / bin/bash
#cli是容器名称
#ubuntu是镜像名称
#-it是以交互方式启动
#bin/bash是启动容器时执行的命令

//查看容器日志
docker logs -f cli  

//查看主机上的容器，-a会显示已停止的容器
docker ps -a

//查看容器映射的端口
docker port peer0.org1.example.com

//删除容器，cli为容器名称或id
docker rm cli  

//查看帮助文档
docker --help

docker ps --help  //查看docker ps的帮助指令

【获取容器相关信息】

0.docker version #查看版本号

1.docker run ...#创建并启动一个容器

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

参数：
-d: 后台运行容器并返回容器ID
-p: 端口映射，格式为：主机(宿主)端口:容器端口
--name: 为容器指定一个名称
#该命令：用nginx镜像启动一个容器，命名为webserver,并映射了80端口。以便用浏览器访问nginx服务器

//地址栏访问：http://localhost 即显示nginx

Eg2:

docker run \ #运行容器的命令
-it \    #这是两个参数，一个是 -i：交互式操作，一个是 -t 终端(若要进入 bash 执行一些命令并查看返回结果，需要交互式终端)
--rm \    #容器退出后随之将其删除
ubuntu:16.04 \ #用ubuntu:16.04 镜像为基础来启动容器
bash    #放在镜像名后的是"命令"，希望有个交互式Shell应用bash

//退出容器:exit

2.docker ps #显示状态为运行（Up）的容器

3.docker ps -a #显示所有容器,包括运行中（Up）的和退出的(Exited)

4.docker stop 容器NAMES #停止容器运行，发送信号SIGTERM

5.docker start 容器NAMES #启动一个停止状态的容器

6.docker restart 容器NAMES #重启一个容器

7.docker rm 容器NAMES #删除一个容器

8.docker diff 容器名(webserver) #查看具体的改动（本示例修改nginx启动显示为Hello Docker!）

//docker中 启动所有的容器命令

docker start $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中关闭所有的容器命令

docker stop $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中删除所有的容器命令

docker rm $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中删除所有的镜像

docker rmi $(docker images | awk ''{print $3}'' |tail -n +2)   //tail -n +2 表示从第二行开始读取

Docker 与宿主机间互拷文件

//从容器里拷备文件到宿主机
docker cp containerid：/usr/local/*.js  /dir

//从宿主机拷备文件到容器
docker cp /dir/*.js containerid：/usr/local/

*** 慎用 docker commit

//定制镜像
docker commit [选项] <容器ID或容器名> [<仓库名>[:<标签>]]

docker commit \
    --author "shiyufeng <shiyufeng@gmail.com>" \  #修改作者
    --message "modify default webpage" \    #本次修改内容
    webserver \  
    nginx:v2

//查看新定制的镜像
docker image ls nginx

//查看镜像内的历史记录
docker history nginx:v2

//运行新定制的镜像，容器名为web2
docker run --name web2 -d -p 81:80 nginx:v2

【镜像操作】

0.docker info #查看docker配置信息，可查看镜像是否配置成功（key=Registry Mirrors）

1.docker images / docker image ls #显示本地所有的镜像列表(顶层镜像)

docker image ls ubuntu #根据仓库名列出镜像

docker image ls ubuntu:16.04 #列出某个特定的镜像(仓库名:标签)

docker image ls -a #显示包含中间层镜像的所有镜像 (显示的无标签镜像不要删除，是其他镜像所依赖的镜像)

docker image ls -f since=mongo:3.2 #查看mongo:3.2之后建立的镜像(-f : --filter参数简写,过滤)

docker image ls -f before=mongo:3.2 #查看mongo:3.2之前建立的镜像

docker image ls -f label=com.example.version=0.1 #通过镜像构建时指定的label过滤

docker image ls -q    #列出所有镜像ID

docker image ls -q redis #列出所有仓库名为redis的镜像ID

docker image ls --format "{{.ID}}: {{.Repository}}" #列出镜像ID和Reopository

docker image ls --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}" #表格等距显示，并且有自定义标题行

2.docker rmi IMAGE_ID #删除一个镜像

docker image rm IMAGE_ID #应用IMAGE_ID删除镜像：IMAGE_ID可为短ID（取前3个即可）也可为长ID

docker image rm NAMES #应用镜像名删除镜像(docker ps -a查看镜像名)

docker image rm DIGEST #应用镜像摘要删除镜像(docker image ls --digests #查看镜像摘要)

##批量删除

docker image rm $(docker image ls -q redis) #删除所有仓库名为redis的镜像（列出所有仓库名为redis的镜像ID）

docker image rm $(docker image ls -q -f before=mongo:3.2) #删除所有在 mongo:3.2 之前的镜像

//docker中 启动所有的容器命令

docker start $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中关闭所有的容器命令

docker stop $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中删除所有的容器命令

docker rm $(docker ps -a | awk ''{ print $1}'' | tail -n +2)

//docker中删除所有的镜像

docker rmi $(docker images | awk ''{print $3}'' |tail -n +2)   //tail -n +2 表示从第二行开始读取

3.docker pull --help #查看docker pull选项帮助

4.docker pull ubuntu:16.04 #从仓库(docker_hub)下载镜像到本地

5.docker image ls -f dangling=true #仓库名、标签均为 <none> 的镜像。这类无标签镜像也被称为 虚悬镜像(dangling image)

6.docker image prune #删除虚悬镜像

docker system df #查看镜像、容器、数据卷所占用的空间

docker tag hyperledger/fabric-tools:x86_64-1.0.0 hyperledger/fabric-tools:latest //给镜像文件打标签，x86_64-1.0.0标记为latest

删除常见问题 & 解决 image is referenced in multiple repositories

执行：docker image rm $(docker image ls -q hyperledger/fabric-ca) 报上述错误。

错误原因：镜像 id 指向了两个 repository，因此无法删除。

执行：docker rmi repository 删除即可。//respository 方式删除。

【定制镜像 & 构建镜像】

https://yeasy.gitbooks.io/docker_practice/image/build.html

1。定制镜像

Eg1:以nginx镜像为基础，定制镜像

//创建包mynginx
mkdir mynginx  
//进入包mynginx
cd mynginx     
//创建文件Dockerfile文本文件
touch Dockerfile  
//编辑Dockerfile文本文件
vi Dockerfile   
##add content start
//From指定基础镜像(定制镜像以一个镜像为基础，在其上定制)【必须&第一条指令】
FROM nginx   
//RUN用来执行命令行命令
RUN echo ''<h1>Hello, Docker!</h1>'' > /usr/share/nginx/html/index.html 
## add content end

Eg2:不以任何镜像为基础，以下指令作为第一层开始存在
//scratch为虚拟镜像，并不实际存在
FROM scratch 
...

2。构建镜像

//构建镜像(在Dockerfile文件目录下执行),指定镜像名称：-t nginx:v3 "."表示当前目录,即指定上下文路径
docker build -t nginx:v3 .   #docker build会将"."指定的上下方目录的内容打包交给Docker引擎以构建镜像

说明：

构建镜像语法格式：

docker build [选项] <上下文路径/URL/->

镜像构建过程：每一条命令即指定一层

Step2/2: RUN 指令启动了一个容器 d5b8fb...，执行了所要求的命令，删除了用到的容器 d5b8fb...，并最后提交了这一层 632ba...

注意：镜像构建上下文（Context）

"." : 表示当前目录，而 Dockerfile 就在当前目录。

docker build 工作原理：

docker 在运行时分为 “Docker 引擎 (服务端守护进程)” 和 “客户端工具”。

1。Docker 引擎：提供了一组 REST API，称为 Docker Remote API。

   docker 命令这样的客户端工具是通过这组 API 与 Docker 引擎交互，以完成各种功能。

因此，虽然表面上我们好像是在本机执行各种 docker 功能，但实际上，一切都是使用的远程调用形式在服务端（Docker 引擎）完成。也因为这种 C/S 设计，让我们操作远程服务器的 Docker 引擎变得轻而易举

【查看日志】

//命令格式
docker logs --help   //查看帮助

//语法：
docker logs [选项] CONTAINER

Options:
        --details        显示更多的信息
    -f, --follow         跟踪实时日志
        --since string   显示自某个timestamp之后的日志，或相对时间，如42m（即42分钟）
        --tail string    从日志末尾显示多少行日志， 默认是all
    -t, --timestamps     显示时间戳
        --until string   显示自某个timestamp之前的日志，或相对时间，如42m（即42分钟）


//查看指定时间后的日志，只显示最后100行：
$ docker logs -f -t --since="2018-02-08" --tail=100 CONTAINER_ID

//查看最近30分钟的日志:
$ docker logs --since 30m CONTAINER_ID

//查看某时间之后的日志
$ docker logs -t --since="2018-02-08T13:23:37" CONTAINER_ID

//查看某时间段日志：
$ docker logs -t --since="2018-02-08T13:23:37" --until "2018-02-09T12:23:37" CONTAINER_ID

 工作中遇到的问题与解决方案：

1。如何解决 image has dependent child images 错误

docker image inspect --format=''{{.RepoTags}} {{.Id}} {{.Parent}}'' $(docker image ls -q --filter since=imageId)

显示所有 imageId，确认处理即可。

Docker 学习网址：https://yeasy.gitbooks.io/docker_practice/image/commit.html

Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock

在 Docker 容器里面使用 docker run/docker build？

Docker 容器技术目前是微服务/持续集成/持续交付领域的第一选择。而在 DevOps 中，我们需要将各种后端/前端的测试/构建环境打包成 Docker 镜像，然后在需要的时候，Jenkins 会使用这些镜像启动容器以执行 Jenkins 任务。

为了方便维护，我们的 CI 系统如 Jenkins，也会使用 Docker 方式部署。 Jenkins 任务中有些任务需要将微服务构建成 Docker 镜像，然后推送到 Harbor 私有仓库中。 或者我们所有的 Jenkins Master 镜像和 Jenkins Slave 镜像本身都不包含任何额外的构建环境，执行任务时都需要启动包含对应环境的镜像来执行任务。

我们的 Jenkins Master、Jenkins Slaves 都是跑在容器里面的，该如何在这些容器里面调用 docker run 命令启动包含 CI 环境的镜像呢？ 在这些 CI 镜像里面，我们从源码编译完成后，又如何通过 docker build 将编译结果打包成 Docker 镜像，然后推送到内网仓库呢？

答案下面揭晓。

一、原理说明：/var/run/docker.sock

Docker 采取的是 Client/Server 架构，我们常用的 docker xxx 命令工具，只是 docker 的 client，我们通过该命令行执行命令时，实际上是在通过 client 与 docker engine 通信。

我们通过 apt/yum 安装 docker-ce 时，会自动生成一个 systemd 的 service，所以安装完成后，需要通过 sudo systemctl enable docker.service 来启用该服务。 这个 Docker 服务启动的，就是 docker engine，查看 /usr/lib/systemd/system/docker.service，能看到有这样一条语句：

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

默认情况下，Docker守护进程会生成一个 socket（/var/run/docker.sock）文件来进行本地进程通信，因此只能在本地使用 docker 客户端或者使用 Docker API 进行操作。 sock 文件是 UNIX 域套接字，它可以通过文件系统（而非网络地址）进行寻址和访问。

因此只要以数据卷的形式将 docker 客户端和上述 socket 套接字挂载到容器内部，就能实现 "Docker in Docker"，在容器内使用 docker 命令了。具体的命令见后面的「示例」部分。

要记住的是，真正执行我们的 docker 命令的是 docker engine，而这个 engine 跑在宿主机上。所以这并不是真正的 "Docker in Docker".

二、示例

在容器内部使用宿主机的 docker，方法有二：

1. 命令行方式：将 /usr/bin/docker 映射进容器内部，然后直接在容器内部使用这个命令行工具 docker
   • 需要的时候，也可以将 /etc/docker 文件夹映射到容器内，这样容器内的 docker 命令行工具也会使用与宿主机同样的配置。
2. 编程方式：在容器内部以编程的方式使用 docker
   • 通过 python 使用 docker: 在 Dockerfile 中通过 pip install docker 将 docker client 安装到镜像中来使用

容器的启动方式也有两种，如下：

1. 直接通过 docker 命令启动

示例命令如下：

docker run --name <name> \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v /usr/bin/docker:/usr/bin/docker \
    --user root \
    <image-name>:<tag>

**必须以 root 用户启动！（或者其他有权限读写 /var/run/docker.sock 的用户）**然后，在容器内就能正常使用 docker 命令，或者访问宿主机的 docker api 了。

2. 使用 docker-compose 启动

docker-compose.yml 文件内容如下：

version: ''3.3''
services:
  jenkins-master:
    image: jenkinsci/blueocean:latest
    container_name: jenkins-master
    environment:
      - TZ=Asia/Shanghai  # 时区
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - ./jenkins_home:/var/jenkins_home  # 将容器中的数据映射到宿主机
      - /usr/bin/docker:/usr/bin/docker  # 为容器内部提供 docker 命令行工具（这个随意）
      - /var/run/docker.sock:/var/run/docker.sock  # 容器内部通过 unix socket 使用宿主机 docker engine
    user: root  # 必须确保容器以 root 用户启动！（这样它才有权限读写 docker.socket）
    restart: always

然后通过 docker-compose up -d 即可后台启动容器。

Docker 中的 uid 与 gid

通过上面的操作，我们在容器内执行 docker ps 时，还是很可能会遇到一个问题：权限问题。

如果你容器的默认用户是 root，那么你不会遇到这个问题，因为 /var/run/docker.sock 的 onwer 就是 root.

但是一般来说，为了限制用户的权限，容器的默认用户一般都是 uid 和 gid 都是 1000 的普通用户。这样我们就没有权限访问 /var/run/docker.sock 了。

解决办法：

方法一（不一定有效）：在构建镜像时，最后一层添加如下内容：

# docker 用户组的 id，通常都是 999
RUN groupadd -g 999 docker \
    && usermod -aG docker <your_user_name>

这样我们的默认用户，就能使用 docker 命令了。

P.S. 999 不一定是 docker 用户组，所以上述方法某些情况下可能失效。这时还是老老实实通过 docker run -u root 启动容器吧。（或者在 docker-compose.yml 中添加 user: root 属性）

参考

• Docker in Docker - 王柏元

Docker Windows Boot2Docker/Linux version 4.9.89-boot2docker/SSH login

 ###  断网

C:\Users\Administrator>

C:\Users\Administrator>"C:\Program Files\Git\bin\bash.exe" --login -i "C:\Program Files\Docker ToolBox\start.sh"
Running pre-create checks...
(default) Unable to get the latest Boot2Docker ISO release version:  Get https://api.github.com/repos/boot2docker/boot2docker/releases/latest: dial tcp: lookup api.github.com: no such host
Creating machine...
(default) Unable to get the latest Boot2Docker ISO release version:  Get https://api.github.com/repos/boot2docker/boot2docker/releases/latest: dial tcp: lookup api.github.com: no such host
(default) copying C:\Users\Administrator\.docker\machine\cache\boot2docker.iso to C:\Users\Administrator\.docker\machine\machines\default\boot2docker.iso...
(default) Creating VirtualBox VM...
(default) Creating SSH key...
(default) Starting the VM...
(default) Check network to re-create if needed...
(default) Windows might ask for the permission to create a network adapter. Sometimes, such confirmation window is minimized in the taskbar.
(default) Found a new host-only adapter: "VirtualBox Host-Only Ethernet Adapter #4"
(default) Windows might ask for the permission to configure a network adapter. Sometimes, such confirmation window is minimized in the taskbar.
(default) Windows might ask for the permission to configure a dhcp server. Sometimes, such confirmation window is minimized in the taskbar.
(default) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
copying certs to the local machine directory...
copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: C:\Program Files\Docker ToolBox\docker-machine.exe env default

                        ##         .
                  ## ## ##        ==
               ## ## ## ## ##    ===
           /"""""""""""""""""\___/ ===
      ~~~ {~~ ~~~~ ~~~ ~~~~ ~~~ ~ /  ===- ~~~
           \______ o           __/
             \    \         __/
              \____\_______/

docker is configured to use the default machine with IP 192.168.99.100
For help getting started, check out the docs at https://docs.docker.com

Start interactive shell

Administrator@Win10 MINGW64 ~
$ boot2docker status
bash: boot2docker: command not found

Administrator@Win10 MINGW64 ~
$ ssh  lake@192.168.99.100
The authenticity of host '192.168.99.100 (192.168.99.100)' can't be established.
ECDSA key fingerprint is SHA256:XG+WBjjl/PP3ksIJ8B4QFSrQ4OsmNn1cyoLMeEyLkuc.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '192.168.99.100' (ECDSA) to the list of kNown hosts.
lake@192.168.99.100's password:
Permission denied, please try again.
lake@192.168.99.100's password:
Permission denied, please try again.
lake@192.168.99.100's password:
lake@192.168.99.100: Permission denied (publickey,password,keyboard-interactive).

Administrator@Win10 MINGW64 ~
$

Administrator@Win10 MINGW64 ~
$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:6540fc08ee6e6b7b63468dc3317e3303aae178cb8a45ed3123180328bcc1d20f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitIoUs, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Administrator@Win10 MINGW64 ~
$ docker run hello-world

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitIoUs, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Administrator@Win10 MINGW64 ~
$

############  ssh login in Docker 

Administrator@Win10 MINGW64 ~
$  docker-machine start default
Starting "default"...
Machine "default" is already running.

Administrator@Win10 MINGW64 ~
 

Administrator@Win10 MINGW64 ~
$  docker-machine ls
NAME      ACTIVE   DRIVER       STATE     URL                         SWARM   DOCKER        ERRORS
default   *        virtualBox   Running   tcp://192.168.99.100:2376           v18.03.0-ce

Administrator@Win10 MINGW64 ~
$  docker-machine  ssh default
                        ##         .
                  ## ## ##        ==
               ## ## ## ## ##    ===
           /"""""""""""""""""\___/ ===
      ~~~ {~~ ~~~~ ~~~ ~~~~ ~~~ ~ /  ===- ~~~
           \______ o           __/
             \    \         __/
              \____\_______/
 _                 _   ____     _            _
| |__   ___   ___ | |_|___ \ __| | ___   ___| | _____ _ __
| '_ \ / _ \ / _ \| __| __) / _` |/ _ \ / __| |/ / _ \ '__|
| |_) | (_) | (_) | |_ / __/ (_| | (_) | (__|   <  __/ |
|_.__/ \___/ \___/ \__|_____\__,_|\___/ \___|_|\_\___|_|
Boot2Docker version 18.03.0-ce, build HEAD : 404ee40 - Thu Mar 22 17:12:23 UTC 2018
Docker version 18.03.0-ce, build 0520e24
docker@default:~$ uname -a
Linux default 4.9.89-boot2docker #1 SMP Thu Mar 22 17:02:51 UTC 2018 x86_64 GNU/Linux
docker@default:~$ cat /proc/version
Linux version 4.9.89-boot2docker (root@e63d0b14ae7b) (gcc version 6.3.0 20170516 (Debian 6.3.0-18+deb9u1) ) #1 SMP Thu Mar 22 17:02:51 UTC 2018
docker@default:~$

docker@default:~$ ifconfig
docker0   Link encap:Ethernet  HWaddr 02:42:47:36:CA:BC
          inet addr:172.17.0.1  Bcast:172.17.255.255  Mask:255.255.0.0
          inet6 addr: fe80::42:47ff:fe36:cabc/64 Scope:Link
          UP broADCAST MULTICAST  MTU:1500  Metric:1
          RX packets:0 errors:0 dropped:0 overruns:0 frame:0
          TX packets:4 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:0
          RX bytes:0 (0.0 B)  TX bytes:348 (348.0 B)

eth0      Link encap:Ethernet  HWaddr 08:00:27:6C:E7:AB
          inet addr:10.0.2.15  Bcast:10.0.2.255  Mask:255.255.255.0
          inet6 addr: fe80::a00:27ff:fe6c:e7ab/64 Scope:Link
          UP broADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:1031 errors:0 dropped:0 overruns:0 frame:0
          TX packets:686 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:204621 (199.8 KiB)  TX bytes:179896 (175.6 KiB)

eth1      Link encap:Ethernet  HWaddr 08:00:27:F4:EC:FC
          inet addr:192.168.99.100  Bcast:192.168.99.255  Mask:255.255.255.0
          inet6 addr: fe80::a00:27ff:fef4:ecfc/64 Scope:Link
          UP broADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:176 errors:0 dropped:0 overruns:0 frame:0
          TX packets:126 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:36612 (35.7 KiB)  TX bytes:33784 (32.9 KiB)

lo        Link encap:Local Loopback
          inet addr:127.0.0.1  Mask:255.0.0.0
          inet6 addr: ::1/128 Scope:Host
          UP LOOPBACK RUNNING  MTU:65536  Metric:1
          RX packets:32 errors:0 dropped:0 overruns:0 frame:0
          TX packets:32 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1
          RX bytes:2752 (2.6 KiB)  TX bytes:2752 (2.6 KiB)

docker@default:~$
docker@default:~$
docker@default:~$
docker@default:~$ df
Filesystem                Size      Used Available Use% Mounted on
tmpfs                   896.1M    227.5M    668.6M  25% /
tmpfs                   497.8M         0    497.8M   0% /dev/shm
/dev/sda1                17.9G     45.1M     16.9G   0% /mnt/sda1
cgroup                  497.8M         0    497.8M   0% /sys/fs/cgroup
c/Users                 200.0G    136.2G     63.8G  68% /c/Users
/dev/sda1                17.9G     45.1M     16.9G   0% /mnt/sda1/var/lib/docker
docker@default:~$ mount
tmpfs on / type tmpfs (rw,relatime,size=917576k)
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,relatime)
devpts on /dev/pts type devpts (rw,relatime,mode=600,ptmxmode=000)
tmpfs on /dev/shm type tmpfs (rw,relatime)
fusectl on /sys/fs/fuse/connections type fusectl (rw,relatime)
/dev/sda1 on /mnt/sda1 type ext4 (rw,relatime,data=ordered)
cgroup on /sys/fs/cgroup type tmpfs (rw,relatime,mode=755)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,relatime,cpuset)
cgroup on /sys/fs/cgroup/cpu type cgroup (rw,relatime,cpu)
cgroup on /sys/fs/cgroup/cpuacct type cgroup (rw,relatime,cpuacct)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,relatime,blkio)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,relatime,memory)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,relatime,devices)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,relatime,freezer)
cgroup on /sys/fs/cgroup/net_cls type cgroup (rw,relatime,net_cls)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,relatime,perf_event)
cgroup on /sys/fs/cgroup/net_prio type cgroup (rw,relatime,net_prio)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,relatime,hugetlb)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,relatime,pids)
c/Users on /c/Users type vBoxsf (rw,nodev,relatime)
/dev/sda1 on /mnt/sda1/var/lib/docker type ext4 (rw,relatime,data=ordered)
docker@default:~$ cat /proc/cpuinfo
processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 158
model name      : Intel(R) Core(TM) i7-8850H cpu @ 2.60GHz
stepping        : 10
cpu MHz         : 2592.000
cache size      : 9216 KB
physical id     : 0
siblings        : 1
core id         : 0
cpu cores       : 1
apicid          : 0
initial apicid  : 0
fpu             : yes
fpu_exception   : yes
cpuid level     : 22
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 syscall nx rdtscp lm constant_tsc rep_good nopl xtopology nonstop_tsc eagerfpu pni pclmulqdq monitor ssse3 cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx rdrand hypervisor lahf_lm abm 3dNowprefetch kaiser avx2 rdseed clflushopt
bugs            : cpu_meltdown spectre_v1 spectre_v2
bogomips        : 5184.00
clflush size    : 64
cache_alignment : 64
address sizes   : 39 bits physical, 48 bits virtual
power management:

docker@default:~$
docker@default:~$
docker@default:~$ free
              total        used        free      shared  buff/cache   available
Mem:        1019528       73460      694980      232924      251088      632748
Swap:       1176084           0     1176084
docker@default:~$
docker@default:~$

Docker 入门（一）Docker 简介与安装（Linux 环境 centos）

Docker 是一个开源的应用容器引擎，基于 Go 语言并遵从 Apache2.0 协议开源。 Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。 容器是完全使用沙箱机制，相互之间不会有任何接口（类似于 app）, 更重要的是容器性能开销极低。

1. Docker 解决的问题

• 解决运行环境和配置问题，方便发布，方便做持续集成。
  • 由于不同的机器有不同的操作系统，以及不同的库和组件，在将一个应用部署到多台机器上需要进行大量的环境配置操作。
  • Docker 主要解决环境配置问题，它是一种虚拟化技术，对进程进行隔离，被隔离的进程独立于宿主操作系统和其它隔离的进程。
  • 使用 Docker 可以不修改应用程序代码，不需要开发人员学习特定环境下的技术，就能够将现有的应用程序部署在其它机器上。
• 使用 Docker 的好处：
  • 部署方便且安全，隔离性好，快速回滚，成本低
• Docker 的应用场景：
  • Web 应用的自动化打包和发布。
  • 自动化测试和持续集成、发布。
  • 在服务型环境中部署和调整数据库或其他的后台应用。

2. Docker 架构

Docker 使用客户端 - 服务器 (C/S) 架构模式，使用远程 API 来管理和创建 Docker 容器。 Docker 容器通过 Docker 镜像 (Images) 来创建，容器与镜像的关系类似于面向对象编程中的对象与类。

• Docker 镜像 (Images)
  • 用于创建 Docker 容器 (Container) 的模板。
• Docker 容器 (Container)
  • 独立运行的一个或一组应用。
• Docker 客户端 (Client)
  • 通过命令行或者其他工具使用 Docker API 与 Docker 的守护进程通信。
• Docker 主机 (Host)
  • 一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。
• Docker 仓库 (Registry)
  • 用来保存镜像 (Images)，可以理解为代码控制中的代码仓库，Docker Hub 提供了庞大的镜像集合供使用。
• Docker Machine
  • 一个简化 Docker 安装的命令行工具，通过一个简单的命令行即可在相应的平台上安装 Docker。

3. CentOS 下安装 Docker

要求 CentOS 6.5 或更高的版本，要求系统为 64 位、系统内核版本为 2.6.32-431 或者更高版本。 这里演示环境 CentOS 8.2。

• 添加 Docker 存储库
  • 首先，必须添加一个外部存储库以获得 Docker CE。这里使用官方的 Docker CE CentOS 存储库。

1. 下载 docker-ce 的 repo

[root@localhost jenkins]# curl https://download.docker.com/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  1919  100  1919    0     0   3408      0 --:--:-- --:--:-- --:--:--  3402

2. 安装依赖

[root@localhost jenkins]# yum install https://download.docker.com/linux/fedora/32/x86_64/stable/Packages/containerd.io-1.3.7-3.1.fc32.x86_64.rpm

3. 安装 docker-ce

[root@localhost jenkins]# yum install docker-ce

4. 启动 docker

[root@localhost jenkins]# systemctl start docker

5. 检查 docker 服务是否正常运行：

[root@localhost jenkins]# systemctl status docker

6. 测试运行 hello-world
   • 由于本地没有 hello-world 这个镜像，所以会下载一个 hello-world 的镜像，并在容器内运行。

[root@localhost jenkins]# docker run hello-world
Unable to find image ''hello-world:latest'' locally
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete 
Digest: sha256:8c5aeeb6a5f3ba4883347d3747a7249f491766ca1caa47e5da5dfcf6b9b717c0
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Docker 搭建测试环境一（Linux 安装 Docke ；Docke 安装 MySQL、Tomcat、Linux、nginx 集成 连个Tomcat环境）

性能测试环境搭建(一)

环境概况

docker 基础知识

docker 搭建数据库

性能测试环境搭建(二)

docker 搭建 tomcat 项目

docker 搭建 Nginx 集群

jmeter 进行集群

性能测试性能测试环境搭建(三)

docker-link 搭建 tomcat-MysqL

docker-link 搭建 tomcat-Nginx 集群

一、性能测试环境搭建：虚拟机 + Linux + Docke + MysqL

1、环境概况

操作系统：linux

• • 云服务器：自己购买
  • 虚拟机：自行安装就好了；从给的百度网盘下载 ova 文件

数据库：MysqL

应用中间件：tomcat + Nginx（译：恩就死：反向代理，负载均衡的集群)

下图说明：Linux 服务器 里面装了 MysqL 和 Tomcat + Nginx（实际的企业里面 MysqL 和 Tomcat + Nginx 应用程序不会装在一个机器上）

tomcat 可以用很多个

环境搭建方式：

• • 手工：经典、传统、用时比较长、需要一定基础工具
  • docker：潮流、快捷----课程选用

二、环境搭建

1、安装虚拟机 vmware 自行安装

　　（安装了 vmware 之后 一定 要重启动电脑）

2、安装 CentOS linux 7 系统

　　1、打开位置：文件 --- 打开 --- 选择 ova （Linux系统）文件

　　2、点击“导入”，会提示失败，但是没有关系 点击 “重试”就可以

• 虚拟机已经安装了 Linux ，安装好了就可以使用

　　3、修改 “编辑虚拟机设置” 配置

　　4、如果出现 下图提示，不用管

　　5、如果出现 “ 此主机支持Intel VT-x,但Intel VT-x处于禁用状态”

 　　修改配置：https://jingyan.baidu.com/article/59a015e3929235b695886539.html

　　6、设置 root 密码（输入密码时是看不到的123456）；

• 使用 ifconfig 查看 ip地址（之后会用到）
• 使用 java -version 查看 jdk 版本

三、Docker 基本知识

1、Docker基础

Docker 是一个 开源 的应用容器引擎，基于 GO 语言，遵循 Apache2.0 开源协议

容器：是一个沙箱，相互之间没有任何接口，自身性能开销极低；相当于袋子

容器内部，其实是一个不全的 linux 内核系统 (cgroups\namespace\UnionFS：三个组成了容器)

2、Docker 特点：

linux 操作系统

资源开销极低

沙箱，容器闻相互隔离

3、应用：

容器组为应用中间件

同一个硬件上运行更多容器

4、Docker组成：

• 镜像 Image：从仓库中复制出来
  • 文件镜像（就像纸张，它有不同的尺寸）
    • 镜像：镜子中的图形

• 容器 Container：
  • 镜像运行的实体（由纸张组成的笔记本，不同尺寸纸张，构成不同大小笔记本)

• 仓库 Repository：
  • 镜像仓库（纸张不同大小，尺寸标签）

Linux 环境下 Docker 安装

1、使用 Xshell 链接刚才创建的 Linux 系统 

　　linux: centos7(root：123456)

　　reboot Now：重启虚拟机

2、安装 docker 第一步：

　　安装 docker 相关依赖：yum install -y yum-utils device-mapper-persistent-data lvm2

3、安装 docker 第二步：

　　一键安装dicker：curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

4、把安装的服务设置为 开机自启动

配置开机启动：systemctl enable docker

重启动 docker：systemctl restart docker

如果在公司里面不是 root 权限需要加（sudo）：sudo systemctl enable docker

　　docker帮助命令：docker --help

6、docker 基本使用

直接 docker --help 帮助命令

• • Usage: docker [OPTIONS] COMMAND
  • docker + 【OPTIONS 选项】 + 命令

  • 

  • 

     

命令：

　　docker pull：我们从仓库里面拉取镜像

　　从 Daocloud 拉取镜像地址： https://hub.daocloud.io/ 

使用 docker 安装 Linux 系统

　　使用命令在 当前 Linux 系统下 在安装一个 Linux  系统，登录镜像地址，查找 centos

　　就可以看到最新的 镜像仓库地址 和 版本

docker images：查看镜像是否存在

docker rmi：删除镜像

　　可以根据 IMAGE ID 删除镜像

docker rm -f 容器名称 or 容器id：删除容器

　　拉取镜像：docker pull daocloud.io/library/centos:latest

　　创建容器：docker run -itd --name bbb_name daocloud.io/library/centos:centos8

docker start 容器名称 or 容器id：启动容器

docker restart 容器名称 or 容器id：重启容器

docker stop 容器名称 or 容器id：停止

docker exec：退出

docker ps -a：在加上 -a，查看所有运行和未运行的容器

docker pa：查看正在运行的容器；

docker exec -it 容器名称或ID /bin/bash：进入容器

exit：退出当前 容器

docker exec -it 容器名称或ID /bin/bash：进入容器

cat /etc/redhat-release：查看发行版本

容器与宿主机之间拷贝文件

从宿主机拷贝文件到容器

• • docker cp 宿主文件路径 容器id:容器内路径　　

从容器拷贝文件到宿主机

• • docker cp容器id:容器内路径 宿主文件路径　　

常用命令：

创建一个新容器并运行

Usage: docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

docker run -itd --name=container_name -p 80:80 -v $PWD:/data Nginx:latest

创建一个 名为 container_name 的容器，拉取的镜像地址

示例：

　　先拉取镜像：docker pull daocloud.io/library/centos:latest

　　在创建容器：docker run -itd --name bbb_name daocloud.io/library/centos:centos8

options 选项：

-i：以交互模式运行容器

-t：为容器重新分配一个伪输终端

-d：后台运行容器

-e username="value：设置环境变量

-p：指定端口映射主机端口:容器端口

-v：本地文件路径映射到容器路径

--name=""：指定容器名称

--link=[ ]：添加链接到另一个容器(--link 容器 A 名称：别名).

Linux 系统安装 vi 命令

　　命令：yum install vim -y

验证vim 命令，创建文件：vim 2.txt

　　操作 2.txt 文件：i 进入编辑状态，随意输入内容，ESC 退出编辑状态，：wq 保存名退出

Docker 搭建 MysqL 数据库

第一步：dockerhub 国内网站，确定要安装的版本

• 建议: https://hub.daocloud.io/

第二步：下载镜像

　　docker pull daocloud.io/library/MysqL:5.7.4

第三步：创建 MysqL 数据库容器：

没有开机自启动

docker run -itd --name aaa_MysqL_577 -p 3316:3306 -e MysqL_ROOT_PASSWORD=root123456 daocloud.io/library/MysqL:5.7.7

开机自启动命令

docker run -itd --restart always --name aaa_MysqL_577 -p 3316:3306 -e MysqL_ROOT_PASSWORD=root123456 daocloud.io/library/MysqL:5.7.7

　　reboot Now：重启虚拟机，可以验证是否是开机自启动

如果没有下载镜像：

开机自启动命令

　　docker run -itd --restart always --name aaa_MysqL_576 -p 3317:3306 -e MysqL_ROOT_PASSWORD=root123456 daocloud.io/library/MysqL:5.7.6

　　会自行下载镜像

链接 MysqL 数据库

　　1、使用 ifconfig 查看 IP地址 + 创建MysqL 时的端口号

　　2、使用工具链接数据库，输入ip 地址、端口号

使用 Navicat Premium 链接 MysqL 数据库

新建数据库；在数据库 新建查询 ，执行表结构 sql；

　　查看表结构是否存在

创建第一个 tomcat 容器：8080端口：

下载镜像:

确定 tomcat 版本: tomcat8、tomcat9

从 dockerhub 中找到对网版本的tag: 8.5.60

下载镜像:docker pull tomcat:8.5.60

创建第1个 tomcat 容器与 MysqL 数据库关联：

docker run -itd --name tomcat4 -p 8084:8080 --link MysqL57:MysqL -v $PWD/logs4:/usr/local/tomcat/logstomcat:8.5.60

-v：转机，本地的某个路径或者某个文件，映射到我的容器里面的某一个路径或者某一个 文件下面去

拷贝项目包到容器

docker cp erp.war tomcat4:/usr/local/tomcat/webapps

修改项目配置：application.yml

• 开发者节点数据库配置修改
  • ip为：MysqL　　
  • 端口为：MysqL 默认端口3306　　

从宿主机拷贝修改后的文件到容器:

docker cp application.yml tomcat4:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

重启动tomcat1容器

docker restart tomcat4

1、拉取镜像：

docker pull daocloud.io/library/tomcat:9.0.0-jre8

• • jre8：Java 运行环境　　
  • jdk：Java 开发工具包，jdk 包含 jre　　

　　查看镜像是否存在：docker images

2、使用这个镜像创建容器 8080

　　docker run -itd --name tomcat_2 -p 8580:8080 daocloud.io/library/tomcat:9.0.0-jre8

3、拷贝项目包到容器根目录

4、移动后查看

5、拷贝项目包到容器:

　　docker cp erp.war tomcat_2:/usr/local/tomcat/webapps

　　验证是否拷贝进去了

　　进入 tomc ：docker exec -it tomcat_2 /bin/bash

　　把项目 war 包放到 Tomcat 文件下 会自动解压 erp 文件夹　　

6、erp 项目配置修改

/webapps/erp/WEB-INF/classes/application.yml

具体路径：/usr/local/tomcat/webapps/erp/WEB-INF/classes

这个文件可以修改数据库配置，只需要修改开发环境，以及日志文件地址

编辑配置文件 application.yml 发现没有 vi 命令

　　1、可以在这里安装 vi 命令

　　2、也可 在这里（容器）拷贝出来 修改后 在拷贝到容器里面，这样 容器里面就不需要安装 vi 命令

7、从容器中拷贝配置文件到宿主机器：$PWD（表示当前 路径）

docker cp tomcat_2:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml $PWD

8、修改项目配置：application.yml

使用 vim 命令未找到命令：说明为安装 vim 命令

yum install vim -y

vi 和 vim 的区别：vim 有颜色，vi 是系统自带的

开发者节点数据库配置修改

1. ip 为宿主机 ip
2. 端口为 MysqL 容器映射给宿主机的端口
3. 修改数据库账号密码

9、从宿主机拷贝修改后的文件到容器:

docker cp application.yml tomcat_2:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

10、修改后需要重启容器：Tomcat_2　　

docker restart tomcat_2

11、创建数据库 erp 表（上面已经创建了，省略）

12、验证项目：jmeter

方法1：查看 logs 文件夹中的日志

方法2：通过接口工具调接口

　　jmeter 验证注册接口请求成功

 　在数据库中查看表中是否存在数据

创建第二个 Tomcat 容器：

1、使用这个镜像创建容器 8080

docker run -itd --name tomcat_3 -p 8680:8080 daocloud.io/library/tomcat:9.0.0-jre8

2、拷贝项目包到容器：

docker cp erp.war tomcat_3:/usr/local/tomcat/webapps

3、从宿主机拷贝修改后的文件到容器：

docker cp application.yml tomcat_3:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

4、修改后需要重启容器 Tomcat_2　　

docker restart tomcat_3

验证项目：

方法1：查看 logs 文件夹中的日志

方法2：通过接口工具调接口

　　jmeter 验证注册接口请求成功；以写入数据库

 　　在数据库表中查看数据是否存在

Nginx 基础

Nginx 是一个高性能性能的HTTP和反向代理web服务器

主要用途：
• web服务器
• 反向代理
• 负载均衡

Docker 安装 Nginx；实现容器间关联搭建Tomcat

下载镜像：https://hub.daocloud.io/

　　先拉取镜像：docker pull daocloud.io/library/Nginx:1.13.0-alpine

　　在创建 Nginx 容器：docker run -itd --restart always --name docker-Nginx -p 80:80 daocloud.io/library/Nginx:1.13.0-alpine

现在我们存在两个公司 Tomcat 项目，想要配置为集群；

需要修改 Nginx 配置文件

Nginx 容器配置：

1、从Nginx 容器中拷贝配置文件到宿主机

docker cp docker-Nginx:/etc/Nginx/Nginx.conf $PWD

2、修改 Nginx.conf 文件

　　网盘链接：https://pan.baidu.com/s/1oMtiAZ11vi747iQ8inKaPA 提取码：7yaw

先把网盘中修改好的配置文件，放到Linux环境根目录下，已经移动到root下

　　有两个 Tomcat 服务和在一起，修改 ip + 端口号 向外映射；

　　weight = 1：这两个服务的平均负载均衡，平均分配

3、拷贝修改后的 Nginx.conf  文件到容器中

docker cp Nginx.conf docker-Nginx:/etc/Nginx/Nginx.conf

4、重启动 Nginx 容器

docker restart docker-Nginx

5、验证项目接口：

方法1：查看 logs 文件夹中的日志

方法2：通过接口工具调接口；更改端口80

　　jmeter 验证注册接口请求成功；以写入数据库

 　　查看数据库表中是否添加数据

集群测试

常用步骤

创建第1个 tomcat 容器与 MysqL 数据库关联：

docker run -itd --name tomcat4 -p 8084:8080 --link MysqL57:MysqL -v $PWD/logs4:/usr/local/tomcat/logstomcat:8.5.60

-v：转机，本地的某个路径或者某个文件，映射到我的容器里面的某一个路径或者某一个 文件下面去

拷贝项目包到容器

docker cp erp.war tomcat4:/usr/local/tomcat/webapps

修改项目配置：application.yml

• • 开发者节点数据库配置修改
    • ip为：MysqL　　
    • 端口为：MysqL 默认端口3306　　

从宿主机拷贝修改后的文件到容器:

docker cp application.yml tomcat4:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

重启动tomcat1容器

docker restart tomcat4

1、下载镜像：

需要 Tomcat 镜像、及安装好的 MysqL 数据库

2、创建 Tomcat 容器

换其他路径 进行安装 opt

docker run -itd --name tomcat_4 -p 8780:8080 -v $PWD/logs4:/usr/local/tomcat/logs --link aaa_MysqL_577:MysqL575 daocloud.io/library/totomcat:9.0.0-jre8

docker run -itd --name tomcat容器名称 -p 映射到本地端口:8080 -v 当前 Tomcat 日志地址logs，映射到本地的logs4路径下面去 --link 数数据库容器名称:数据库别名 Tomcat镜像地址:Tomcat版本号

--link ：在 Tomcat 容器 与 MysqL 容器之间建立链接，把两个容器创建成一个局域网，都放在一个区域

 　　日志文件位置

查看日志：tailf catalina.2020-12-25.log

实时查看日志：tailf -f catalina.2020-12-25.log

查看日志文件：vim catalina.2020-12-25.log

2、配置文件拷贝当前路径

项目包放进去

 　　配置文件需要拷贝 出来

docker cp  tomcat_4:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml $PWD

修改配置文件：

　　vim application.yml

　　使用别名 MysqL4，不用改端口（因为是两个容器与容器之间的局域网，已经在一起了，没有通过宿主机）

　　修改账号root 密码 root123456

3、从宿主机拷贝修改后的文件到容器

docker cp application.yml tomcat_4:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

4、修改后需要重启容器 Tomcat_4

docker restart tomcat_4

然后去 logs4 查看日志

查看日志：tailf catalina.2020-12-25.log

实时查看日志：tailf -f catalina.2020-12-25.log

查看完整日志文件：vim catalina.2020-12-25.log

1、使用这个镜像创建容器 8080

docker run -itd --name tomcat_5 -p 8880:8080 -v $PWD/logs5:/usr/local/tomcat/logs --link aaa_MysqL_577:MysqL575 daocloud.io/library/tomcat:9.0.0-jre8

2、拷贝项目包到容器:

docker cp erp.war tomcat_5:/usr/local/tomcat/webapps

3、修改后的application.yml 配置文件，从宿主机拷贝修改后的文件到容器:

docker cp application.yml tomcat_5:/usr/local/tomcat/webapps/erp/WEB-INF/classes/application.yml

把这个application文件拷贝到这个容器Tomcat5

4、修改后需要重启容器 Tomcat_5

docker restart tomcat_5

5、然后去 logs5 查看日志

查看日志：tailf catalina.2020-12-25.log

实时查看日志：tailf -f catalina.2020-12-25.log

查看完整日志文件：vim catalina.2020-12-25.log

Docker安装Nginx

下载镜像:

docker pull daocloud.io/library/Nginx:1.13.0-alpine

创建 Nginx 容器:

docker run -itd --restart always --name docker-Nginx2 --link tomcat4:tomcat4 --link tomcat5:tomcat5 -p 8980:80 daocloud.io/library/Nginx:1.13.0-alpine

配置 Nginx 创建集群

　　docker run -itd --restart always --name docker-Nginx2 --link tomcat_4:tomcat4 --link tomcat_5:toncat5 -p 8888:80 daocloud.io/library/Nginx:1.13.0-alpine

　　复制 Nginx.conf  到 opt 目录下：cp Nginx.conf /opt/

　　在 opt 目录下 修改配置：vim Nginx.conf

Nginx 容器配置：

基本配置步骤：

1从 Nginx 容器中拷贝配置文件到宿主机

docker cp docker-Nginx2:/etc/Nginx/Nginx.conf $PWD

2修改 Nginx.conf 文件

3拷贝修改后的 Nginx.conf 文件到容器中

docker cp Nginx.conf docker-Nginx2:/etc/Nginx/Nginx.conf

4重启动 Nginx 容器

docker restart Nginx

拷贝 配置文件 到 容器里面

docker cp Nginx.conf docker-Nginx2:/etc/Nginx/Nginx.conf

重启动 Nginx 容器

docker restart Nginx

接口验证：

Nginx 为什么要使用 --link

1、如果 没有使用link 那么数据就要消耗宿主机的 IO；不使用 Nginx IO 就要消耗的大一些，同时它的内存也要消耗的大一些；随意这样就会导致我的

宿主机相对而言性能要大一些，也就是说最终的性能不是理想；；；；；而使用了 --link 之后，就不会消耗额外的资源了，它的性能就要更好一些，

2、不管请求的数据是多还是少；比如说：请求的报文只有 1kb ,但是我进入容器，然后又出来回到宿主机，那内存里面就要存在 这个2 kv 的数据大小

我的宿主机内存先要有这个数据，然后进入到里面去，从 Nginx 里面在出来，又回到宿主机，那宿主机要接受这个数据，接受这个数据，

在进入 Tomcat 这个容器里面去，我的内存消耗就要大一些

宿主机同样的硬件的配置，使用了 --link 方式，来链接容器，它的性能、速度都会要快很多；；

因为他们几个 组成局域网访问的速度比较快

Nginx 本来就是做负载均衡的，Nginx 要配置负载均衡的时候，配置的是宿主机的 IP 和宿主机的端口

数据流向：比如用户发过来一个请求 到了 Nginx， Nginx 机器先从外面 进入 Nginx 容器里面去，你告诉它要找的是宿主机的 ip，又要回到 宿主机；

再从宿主机看到宿主机的端口，在进入另一个容器里去；

如果用第一种方法 ，不适用 link ；一个访问我的数据库，访问我的网卡，进入到我的服务器里面来了；

就会进入到，因为有一个80 的端口，找到宿主机的 80 端口；宿主机的80端口我就会进入到 Nginx 这个容器里面去，

Nginx 这个容器里面发现它要找的 ip 地址，是我宿主机的 ip地址 和 宿主机的端口；要从 Nginx 容器里面出来，

进入到我的宿主机，找到了这个端口，在进入 Tomcat 容器里面去        它转了一个弯

如果是 link ：用户来访问一个请求，从宿主机的网卡进入到宿主机，找到了Nginx 的端口，就会进入到 Nginx 这个容器里面；

发现 它是一个 内部局域网、容器局域网；容器局域网里面，容器里面它要找的是 容器的别名；直接通过这个找到我的另外一个容器，在容器局域网里面找到了我的另外一个容器；进入到另外一个容器里面，由另外一个容器处理了在出来；   可以少走弯路

我的数据流至少再从容器里面出来一次，进入到宿主机，宿主机在进入到容器

性能的话语就是：首先你的 IO 、速度换入换出要跟少了；首先进入到容器里面，在出来，在进入容器里面去 有很多IO 数据换入换出；

使用link了之后，直接进入 容器里面，我在容器的局域网里面，进行数据的交换，这样就可以不消耗宿主机的 IO；

*******请大家尊重原创，如要转载，请注明出处：转载自：https://www.cnblogs.com/shouhu/，谢谢！！******* 

我们今天的关于linux/Docker和linuxdocker常用命令的分享已经告一段落，感谢您的关注，如果您想了解更多关于Docker in Docker(实际上是 Docker outside Docker): /var/run/docker.sock、Docker Windows Boot2Docker/Linux version 4.9.89-boot2docker/SSH login、Docker 入门（一）Docker 简介与安装（Linux 环境 centos）、Docker 搭建测试环境一（Linux 安装 Docke ；Docke 安装 MySQL、Tomcat、Linux、nginx 集成 连个Tomcat环境）的相关信息，请在本站查询。