Docker实验2----4

Docker概述

虚拟机：在window中装一个VMware，通过这个软件我们可以虚拟出来一台或者多台电脑！笨重

虚拟机也属于虚拟化技术，Docker容器技术，也是一种虚拟化技术

VMware : linux centos 原生镜像（一个电脑！） 隔离、需要开启多个虚拟机！ 几个G 几分钟
docker: 隔离，镜像（最核心的环境 4m + jdk + mysql）十分的小巧，运行镜像就可以了！小巧！ 几个M 秒级启动！

Docker基于Go语言开发的开源项目

docker官网：https://www.docker.com/

文档：https://docs.docker.com/

仓库：https://hub.docker.com/

Docker能干嘛

之前的虚拟机技术
虚拟机技术缺点

1、 资源占用十分多

2、 冗余步骤多

3、 启动很慢！

容器技术

容器化技术不是模拟一个完整的操作系统

比较Docker和虚拟机技术的不同：

• 传统虚拟机，虚拟出一套容器内的应用直接运行在宿主机硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
• 容器内的应用直接运行在宿主机内，容器是没有自己的内核的，也没有虚拟我们的硬件，所以就轻便了
• 每个容器间是相互隔离的，每个容器内都有一个属于自己的文件系统，互不影响

DevOps (开发、运维)

应用更快速的交付和部署

传统：一堆帮助文档，安装程序

Docker：打包镜像发布测试，一键运行

更便捷的升级和扩缩容

使用了Docker之后，我们部署应用就和搭积木一样

项目打包为一个镜像，扩展服务器A! 服务器B

更简单的系统运维

在容器化之后，我们的开发，测试环境都是高度一致的。

更高效的计算资源利用

Docker是内核级别的虚拟化，可以在一个物理机上运行很多个容器实例！服务器的性能可以被压榨到极致。

实验2内容------Docker安装

Docker的基本组成

镜像（image）：

docker镜像就好比是一个目标，可以通过这个目标来创建容器服务，tomcat镜像>run>容器（提供服务器），通过这个镜像可以创建多个容器（最终服务运行或者项目运行就是在容器中的）。

容器（container）:

Docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建的.

启动，停止，删除，基本命令

目前就可以把这个容器理解为就是一个简易的 Linux系统。

仓库（repository）:

仓库就是存放镜像的地方！

仓库分为公有仓库和私有仓库。(很类似git)

Docker Hub是国外的。

阿里云...都有容器服务器 (配置镜像加速!)

安装Docker

环境准备

1.Linux要求内核3.0以上

2.ubuntu22.4

环境查看

# 系统内核
docker@docker:~$ uname -r
6.8.0-40-generic

# 系统版本
docker@docker:~$ cat /etc/os-release 
PRETTY_NAME="Ubuntu 22.04.5 LTS"
NAME="Ubuntu"
VERSION_ID="22.04"
VERSION="22.04.5 LTS (Jammy Jellyfish)"
VERSION_CODENAME=jammy
ID=ubuntu
ID_LIKE=debian
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
UBUNTU_CODENAME=jammy
docker@docker:~$ 

安装

# 1. 清理可能的冲突
sudo apt remove -y podman-docker docker docker-engine docker.io containerd runc 2>/dev/null
sudo apt remove -y docker-ce docker-ce-cli containerd.io 2>/dev/null

# 2. 安装docker.io
sudo apt update
sudo apt install -y docker.io

# 3. 启动服务
sudo systemctl start docker
# 设置开机自启
sudo systemctl enable docker

# 4. 验证安装
docker version

安装成功，我的版本为28.2.2

# 5. 配置用户权限（额外重要步骤）
sudo usermod -aG docker $USER
newgrp docker  # 使权限立即生效

# 6. 配置镜像加速器（使用国内源）
# 停止服务
sudo systemctl stop docker
sudo mkdir -p /etc/docker
sudo apt install -y vim  # 如果没安装vim

sudo vim /etc/docker/daemon.json
# 复制黏贴以下内容
{
    "registry-mirrors": [
        "https://cdoid6va.mirror.aliyuncs.com",      # 阿里云镜像加速器
        "https://docker.mirrors.ustc.edu.cn",       # 中科大镜像源（稳定）
        "https://docker.nju.edu.cn",                # 南京大学镜像源（稳定）
        "https://do.nark.eu.org",                   # 源1
        "https://dc.j8.work",                       # 源2
        "https://docker.m.daocloud.io",             # DaoCloud镜像源
        "https://dockerproxy.com"                   # DockerProxy镜像源
    ]
}

# 重新加载配置并重启Docker
sudo systemctl daemon-reload
sudo systemctl restart docker

# 7. 测试安装
docker run hello-world

#8.查看一下下载的hello-world镜像
docker images

# 检查Docker服务状态
systemctl status docker

# 简写
sudo systemctl status docker

docker的初步操作

（1）查看容器

docker ps -a

（2）运行交互式容器

docker run -it ubuntu /bin/bash

（3）退出容器

exit

（4）启动容器

docker start 容器ID

（5）停止容器

docker stop 容器ID

了解：卸载docker

# 1.卸载依赖（Ubuntu版）
sudo apt remove -y docker-ce docker-ce-cli containerd.io

# 2.删除资源
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

# 删除配置文件
sudo rm -rf /etc/docker

帮助命令

docker version     # 显示docker的版本信息
docker info        # 显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help  # 帮助命令

帮助文档的地址：https://docs.docker.com/engine/reference/commandline/build/

实验3-----Docker镜像管理

镜像是什么

镜像是一种轻量级、可执行的独立软件保，用来打包软件运行环境和基于运行环境开发的软件，他包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件。

所有应用，直接打包docker镜像，就可以直接跑起来

如何得到镜像

• 从远程仓库下载
• 别人拷贝给你
• 自己制作一个镜像 DockerFile

Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

boots(boot file system）主要包含 bootloader和 Kernel, bootloader主要是引导加载 kernel, Linux刚启动时会加载bootfs文件系统，在 Docker镜像的最底层是 boots。这一层与我们典型的Linux/Unix系统是一样的，包括bootloader和 Kernel。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由 bootfs转交给内核，此时系统也会卸载bootfs。

平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M？

对于个精简的OS, rootfs可以很小，只需要包合最基本的命令、工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的Linux发行版， boots基本是一致的， rootfs会有差別，因此不同的发行版可以公用bootfs.

虚拟机是分钟级别，容器是秒级。

基本命令

docker images

docker images

#解释
REPOSITORY  镜像的仓库源
TAG         镜像标签
IMAGE ID    镜像id
CREATED     镜像的创建时间
SIZE        镜像的大小

#可选项
Options:
  -a, --all             # 列出所有镜像
  -q, --quiet           # 只显示镜像id

docker pull 下载镜像

# 下载镜像 docker pull 镜像名[:tag]
#docker pull mysql  #我的电脑是拉取了9.6的

# 指定版本下载
docker pull mysql:8.0

# 查看已下载的MySQL镜像
docker images mysql

1. REPOSITORY: mysql
   • 镜像名称是 <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">mysql</font>（官方 MySQL 镜像）
2. TAG: 8.0
   • 你下载的是 MySQL 8.0 版本
   • 没有指定版本时会默认下载 <font style="color:rgb(15, 17, 21);background-color:rgb(235, 238, 242);">latest</font> 标签
3. IMAGE ID: 67fcbe35dfe8
   • 镜像的唯一标识（这里是前 12 位，完整 ID 更长）
4. CREATED: 17小时前
   • 这个镜像是在 17 小时前构建的
   • 表示这是相对较新的镜像构建
5. SIZE: 786MB
   • 镜像大小是 786MB
   • 包含了 MySQL 8.0 的运行环境和基础系统

docker rmi 删除镜像

docker rmi -f 镜像id  				 #删除指定镜像
docker rmi -f 镜像id 镜像id 镜像id  	   #删除多个镜像
docker rmi -f $(docker images -aq)     #删除全部镜像

1. 基于现有镜像创建

1.1 启动镜像

# 拉取Redis镜像
docker pull redis

---

# 运行Redis容器
# 简单运行
docker run -d --name redis01 redis

# 带端口映射
docker run -d --name redis02 -p 6379:6379 redis

# 查看Redis镜像
docker images redis

# 查看镜像元数据
docker image inspect redis
# 或
docker inspect redis

---

# 进入容器
docker exec -it redis01 /bin/bash

# 使用redis-cli
docker exec -it redis01 redis-cli

# 测试Redis
set test "hello"
get test
exit

1.2 生成新镜像

为了掌握基于现有容器生成新镜像的方法，实验中以 Tomcat 镜像为例进行操作：

#1、启动一个默认的tomcat
# 如果还没有tomcat镜像，先拉取
docker pull tomcat

# 启动一个默认的tomcat
docker run -d --name tomcat-commit -p 8080:8080 tomcat

# 查看是否运行
docker ps

#2、发现这个默认的tomcat是没有webapps应用的，镜像的原因。官方的镜像默认webapps下面是没有文件的！

# 进入容器查看
docker exec -it tomcat-commit /bin/bash

# 查看webapps目录（按指导书：官方的镜像默认webapps下面是没有文件的！）
cd webapps
ls
# 发现是空的

# 查看webapps.dist目录
cd ..
ls
cd webapps.dist/
ls
# 看到有：ROOT docs examples host-manager manager

#3、我自己将webapp.dist下文件拷贝至webapps下
cd ..
cp -r webapps.dist/* webapps/

# 验证
cd webapps
ls
# 现在应该有：ROOT docs examples host-manager manager

# 退出容器
exit

命令解释：

• -m="描述信息"
• -a="作者"
• 容器id
• 目标镜像名:[版本TAG]

#4、将我们操作过的容器通过commit提交为一个镜像！我们以后就可以使用我们修改过的镜像了，这就是我们自己的一个修改的镜像
# 查看容器ID
docker ps
# 容器ID是 1bb00edbc772

# 使用commit命令
docker commit -m="add webapps files" -a="yourname" tomcat-commit tomcat-webapps:1.0
# 或使用容器ID
docker commit -m="add webapps files" -a="yourname" 1bb00edbc772 tomcat-webapps:1.0

# 查看新镜像
docker images
# 应该能看到 tomcat-webapps:1.0

# 使用新镜像运行容器
docker run -d --name tomcat-new -p 8081:8080 tomcat-webapps:1.0

# 测试访问
curl localhost:8081

看到Tomcat默认页面

如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比我们我们使用虚拟机的快照

2. 基于本地模板创建

2.1 OpenVZ 下载模板

为了掌握本地模板导入镜像的思路，可先准备一个 Linux 根文件系统模板，例如 OpenVZ 或其他 rootfs 压缩包。模板一般为 .tar 或 .tar.gz 文件，其本质上是一个可作为容器文件系统基础环境的最小系统模板。

2.2 导入容器生成镜像

将本地模板导入 Docker，生成新的镜像：

# 先启动一个正常 Ubuntu 容器
docker run -it --name ubuntu-temp ubuntu:22.04 /bin/bash
# 进去之后简单执行
echo "test import image"
exit

# 导出这个容器为 tar 文件
docker export ubuntu-temp -o ubuntu-rootfs.tar
# 验证
ls -lh ubuntu-rootfs.tar


# 再导入成新镜像
docker import ubuntu-rootfs.tar ubuntu-local:1.0
docker images

# 运行验证
docker run -it ubuntu-local:1.0 /bin/sh
# 进去之后
ls /
cat /etc/os-release

通过 docker import 可以把本地模板直接导入为一个 Docker 镜像。与 docker commit 不同，docker import 更适合从现成系统模板或导出的根文件系统快速生成基础镜像。

3. 基于 Dockerfile 创建

3.1 Dockerfile 结构及分层

第一步：创建一个目录

mkdir mynginx
cd mynginx

第二步：创建 index.html

vim index.html

写入内容（随便写点，方便你验证）：

<h1>Hello Docker Nginx</h1>

保存退出：

Esc
:wq

第三步：创建 Dockerfile

vim Dockerfile

写入（注意：Dockerfile 没有后缀！！！）

FROM ubuntu:22.04
RUN apt update && apt install -y nginx
COPY index.html /var/www/html/index.html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

保存退出

第四步：构建镜像

docker build -t mynginx:1.0 .

第五步：查看镜像

docker images

你应该能看到：

mynginx    1.0

第六步：运行容器

docker run -d --name mynginx -p 8088:80 mynginx:1.0

第七步：测试是否成功

在虚拟机里执行：

curl localhost:8088

如果成功会看到：

<h1>Hello Docker Nginx</h1>

4. 操作常用的指令

实验中使用到的常用镜像管理命令如下：

docker images                  # 查看本地镜像
docker pull redis             # 拉取镜像
docker pull mysql:8.0         # 拉取指定版本镜像
docker image inspect redis    # 查看镜像详细信息
docker inspect redis          # 查看对象详细信息
docker commit 容器名 新镜像名:标签   # 提交容器为新镜像
docker rmi -f 镜像ID          # 删除指定镜像
docker rmi -f $(docker images -aq)   # 删除全部镜像

实验4-----Docker容器管理

1. Docker 容器的创建与管理

1.1 创建并进入容器

有了镜像才可以创建容器，linux,下载一个ubuntu镜像来学习

# 拉取Ubuntu镜像
docker pull ubuntu:22.04

---

新建容器并启动

docker run [可选参数] image

# 参数说明
--name="Name"	容器名字 tomcat01 tomcat02 ，用来区分容器
-d              后台方式运行
-it             使用交互方式运行，进入容器查看内容
-p              指定容器的端口 -p 8080:80
    -p  ip:主机(即宿主机)端口：容器端口
    -p  主机端口：容器端口  #这种方式常用
    -p  容器端口
    容器端口P
-P              随机指定端口(大写P)

# 测试，启动并进入容器
docker run -it ubuntu:22.04 /bin/bash

# 在容器内执行：
ls     # 查看容器内的ubuntu系统
# 注意：Ubuntu基础镜像更精简，你会发现比你的宿主机少很多内容

# 从容器中退回主机
exit

** 1.2 查看容器 **

# docker ps 命令
(不加） # 列出当前正在运行的容器
-a     # 列出当前正在运行的容器 + 带出历史运行过的容器
-n=?   # 显示最近创建的容器
-q    # 只显示当前容器的编号

# 查看当前正在运行的容器
docker ps
# 查看所有容器（包括已停止的）,-a = --all 的简写
docker ps -a
# 查看最近创建的 1 个容器（包括已停止的）
docker ps -a --last=1
# 只显示所有容器的 ID
docker ps -aq

---

退出容器

exit   # 直接退出容器
Ctrl + p + q  # 容器不停止退出

---

** 1.3 删除容器 **

docker rm 容器id				   # 删除指定容器，不能删除正在运行的容器，如果要强制删除 rm -f
docker rm -f $(docker ps -aq)    # 删除所有容器 
docker ps -a -q|xargs docker rm  # 删除所有容器

# 先查看容器ID
docker ps -a
# 删除指定容器（用实际的容器ID替换）
docker rm <容器id>
# 删除所有容器
docker rm -f $(docker ps -aq)
# 或者
docker ps -a -q | xargs docker rm

# 删除所有hello-world容器
docker rm $(docker ps -aq -f ancestor=hello-world)

** 1.4 启动、停止、重启和强制停止容器 **

docker start 容器id     # 启动容器
docker restart 容器id   # 重启容器
docker stop 容器id      # 停止当前正在运行的容器
docker kill 容器id      # 强制停止当前正在运行的容器

# 先创建一个测试容器
docker run -d --name test_container ubuntu:22.04 sleep 3600

docker stop test_container
docker start test_container
docker restart test_container
docker kill test_container

** 1.5 后台启动容器 **

# 命令 docker run -d 镜像名
# 1. 后台启动Ubuntu容器
docker run -d ubuntu:22.04
# 2. 立即查看运行状态
docker ps

** 你会发现容器停止了**

常见的坑，docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止。比如nginx,容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

---

---

** 1.6 查看容器日志 **

docker logs -f -t --tail 数字 容器id

# 显示日志
# -tf         # 显示日志（-t时间戳，-f跟随）
# --tail      # 要显示的日志条数

# 1. 创建一个会持续运行的容器（用于查看日志）
docker run -d --name log_test ubuntu:22.04 /bin/sh -c "while true; do echo 'Test log message'; sleep 2; done"

# 2. 查看容器ID，发现是28526bc6169f
docker ps

# 3. 执行指导书命令
docker logs -f -t --tail 10 28526bc6169f 
# 或
docker logs -tf --tail 10 log_test

---

**1.7 查看容器中的进程 **

# 命令 docker top 容器id
docker top     <容器id>

docker top    28526bc6169f

---

** 1.8 查看容器详细信息 **

# 命令
#docker inspect 容器id

# 1. 先创建一个运行中的容器
docker run -d --name test_inspect ubuntu:22.04 sleep 600

# 2. 查看容器ID
docker ps
# 容器ID是 2cfe2b0fdb62

# 3. 执行指导书命令（用你的实际容器ID）
docker inspect test_inspect
# 或
docker inspect 2cfe2b0fdb62

输出一个JSON，包含容器的详细信息

---

** 1.9 进入运行中的容器 **

# 通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
# 1. 确保有运行中的容器（上面创建的）
docker ps

# 2. 方式一：docker exec
docker exec -it test_inspect /bin/bash

# 在容器内执行
ls
ps -ef
exit  # 退出容器

# 3. 方式二：docker attach
# 重新启动容器（如果是停止状态）
docker start test_inspect

docker attach test_inspect
# 按 Ctrl+P+Q 退出而不停止容器（不是exit）

# docker exec      # 进入容器后开启一个新的终端，可以在里面操作（常用）
# docker attach    # 进入容器正在执行的终端，不会启动新的进程

---

** 1.10 从容器内拷贝文件到宿主机 **

# 命令格式
docker cp 容器id:容器内目标文件路径 目的主机路径

# 1. 查看当前主机目录
ls

# 2. 进入docker容器内部
docker exec -it test_inspect /bin/bash

# 3. 在容器内
# 在exec的bash会话中执行：
cd /home/
ls  # 查看目录
touch test.java
echo "Created with docker exec" > test.java
ls -la  # 确认文件创建

# 重要：这里用exit退出bash，但容器继续运行
exit

# 4. 查看容器状态
docker ps -a

# 如果看到 "Exited"，说明容器停了，需要：docker start test_inspect

# 5. 将docker内文件拷贝到主机上
docker cp test_inspect:/home/test.java /home/docker/

# 6. 验证
ls /home/docker/
# 应该能看到 test.java 文件
# 拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现自动同步

命令汇总

  attach      Attach to a running container 	      # 当前shell下attach连接指定运行的镜像
  build       Build an image from a Dockerfile        # 通过Dockerfile定制镜像
  commit      Create a new image from a container changes  #提交当前容器为新的镜像
  cp          Copy files/folders between a container and the local filesystem #从容器中拷贝指定文件或目录到宿主机中
  create      Create a new container 				  # 创建一个新的容器，同run,但不启动容器
  diff        Inspect changes to files or directories on a container's filesystem #查看docker容器的变化
  events      Get real time events from the server 	  # 从docker服务获取容器实时事件
  exec        Run a command in a running container    # 在已存在的容器上运行命令
  export      Export a container filesystem as a tar archive # 导出容器的内容流作为一个tar归档文件[对应import]
  history     Show the history of an image            # 展示一个镜像形成历史
  images      List images                             # 列出系统当前的镜像
  import      Import the contents from a tarball to create a filesystem image # 从tar包中的内容创建一个新的文件系统镜像[对应export]
  info        Display system-wide information         # 显示系统相关信息
  inspect     Return low-level information on Docker objects # 查看容器详细信息
  kill        Kill one or more running containers     # 杀死指定的docker容器
  load        Load an image from a tar archive or STDIN # 从一个tar包加载一个镜像[对应save]
  login       Log in to a Docker registry			  # 注册或者登录一个docker源服务器
  logout      Log out from a Docker registry		  # 从当前Docker registry退出
  logs        Fetch the logs of a container			  # 输出当前容器日志信息
  pause       Pause all processes within one or more containers 	     # 暂停容器
  port        List port mappings or a specific mapping for the container # 查看映射端口对应容器内部源端口
  ps          List containers						  # 列出容器列表
  pull        Pull an image or a repository from a registry # 从docker镜像源服务器拉取指定镜像或库镜像
  push        Push an image or a repository to a registry   # 推送指定镜像或者库镜像至docker源服务器
  rename      Rename a container					  # 给docker容器重新命名
  restart     Restart one or more containers		  # 重启运行的容器
  rm          Remove one or more containers			  # 移除一个或者多个容器
  rmi         Remove one or more images				  # 移除一个或者多个镜像[无容器使用该镜像时才可删除，否则需删除相关容器才可继续或 -f 强制删除]
  run         Run a command in a new container		  # 创建一个新的容器并运行一个命令
  save        Save one or more images to a tar archive (streamed to STDOUT by default) # 保存一个镜像为一个tar包[对应load]
  search      Search the Docker Hub for images		  # 在docker hub中搜索镜像
  start       Start one or more stopped containers	  # 启动容器
  stats       Display a live stream of container(s) resource usage statistics # 实时显示容器资源使用统计
  stop        Stop one or more running containers	  # 停止容器
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE # 给源中镜像打标签
  top         Display the running processes of a container   	  # 查看容器中运行的进程信息
  unpause     Unpause all processes within one or more containers # 取消暂停容器
  update      Update configuration of one or more containers	  # 更新一个或多个容器配置
  version     Show the Docker version information	  # 查看docker版本号 
  wait        Block until one or more containers stop, then print their exit codes # 截取容器停止时的退出状态值

2. Docker 容器资源控制管理

2.1 部署 Nginx 容器

# 1.搜索镜像 search 建议去docker搜索，可以看到帮助文档
# 2.下载镜像 pull
docker pull nginx
# 3.运行测试
docker images

# -d 后台运行
# --name 给容器命名
# -p 宿主机端口：容器内部端口   【端口映射操作】

docker run -d --name nginx01 -p 3344:80 nginx
# 查看运行状态
docker ps

# 本地测试访问nginx
curl localhost:3344

# 进入容器
docker exec -it nginx01 /bin/bash

# 在容器内执行
whereis nginx
cd /etc/nginx/
ls
exit

---

---

端口暴露的概念

**思考问题：**我们每次改动nginx配置文件，都需要进入容器内部？十分麻烦，我要是可以在容器外部提供一个映射路径，达到在容器外部修改文件名，容器内部就可以自动修改？-v 数据卷 技术

2.2 部署 Tomcat 容器

# 官方文档命令（测试用完即删）
# docker run -it --rm tomcat:9.0
# 按Ctrl+C停止并自动删除容器
# 指导书解释：我们之前的启动都是后台，停止了容器之后，容器还是可以查到

# 下载
docker pull tomcat:9.0

# 启动运行
docker run -d -p 3355:8080 --name tomcat01 tomcat:9.0

#测试访问没有问题(在浏览器http://localhost:3355或者命令行)
curl localhost:3355

# 进入容器发现问题
docker exec -it tomcat01 /bin/bash

# 1、linux命令少了（确实是最小镜像）
# 2、webapps内没有内容（这是阿里云镜像的原因：默认是最小镜像，所有不必要的都删除）
# 保证最小可运行环境
# 在容器内执行
cd webapps
ls
# 发现webapps目录是空的

cd ..
ls
# 看到：BUILDING.txt CONTRIBUTING.md LICENSE NOTICE README.md RELEASE-NOTES RUNNING.txt bin conf lib logs native-jni-lib temp webapps webapps.dist work

cd webapps.dist/
ls
# 看到：ROOT docs examples host-manager manager

cd ..
cp -r webapps.dist/* webapps

cd webapps
ls
# 现在看到：ROOT docs examples host-manager manager

# 退出容器
exit

拷贝完成就可以访问了：

# 重启容器使更改生效
docker restart tomcat01
# 再次测试
curl localhost:3355

浏览器访问http://localhost:3355

**思考问题：**我们以后要部署项目，如果每次都要进入容器是不是十分麻烦？我要是可以在容器外部提供映射路径，webapps,我们在外部放置项目，就自动同步到内部就好了

2.3 部署 Elasticsearch 并观察资源占用

# es 暴露的端口很多！
# es 十分耗内存
# es 的数据一般需要放置到安全目录！挂载
# --net somenetwork？网络配置

# 启动 elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2

# 测试es是否成功
curl localhost:9200

# 查看docker容器占用资源情况
docker stats
# 你会发现ES非常耗内存

# 关闭第一个容器
docker stop elasticsearch
docker rm elasticsearch

# 增加内存限制启动
docker run -d --name elasticsearch02 \
  -p 9200:9200 -p 9300:9300 \
  -e "discovery.type=single-node" \
  -e ES_JAVA_OPTS="-Xms256m -Xmx512m" \
  elasticsearch:7.6.2

# 要等待稍微久一点
curl localhost:9200

# 再次查看资源占用
docker stats
# 现在内存占用会小很多

# 测试
curl localhost:9200