# docker复习笔记

**Repository Path**: abc123ldy520520/docker-review-notes

## Basic Information

- **Project Name**: docker复习笔记
- **Description**: docker复习笔记、docker复习笔记、docker复习笔记
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2023-06-30
- **Last Updated**: 2023-11-24

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 复习
## 1、Docker 镜像相关的命令
    （1）搜索镜像  docker search <镜像名称>    docker search nginx
    （2）下载镜像  docker pull <镜像名称>:<标签>   docker pull nginx:latest
    （3）列出本地镜像  docker images
    （4）删除镜像 docker rmi <镜像名称>:<标签>   docker rmi nginx:latest
    （5）构建镜像 docker build -t <镜像名称>:<标签> <Dockerfile路径>
首先，创建一个名为 Dockerfile 的文件，并在其中定义镜像的构建规则。例如，以下是一个简单的 Dockerfile 示例用于构建一个基于 Ubuntu 的镜像并安装 Nginx：
```
FROM ubuntu:latest
RUN apt-get update && apt-get install -y nginx
CMD ["nginx", "-g", "daemon off;"]
```
然后，在 Dockerfile 所在的目录下运行以下命令来构建一个名为 "my-nginx"，标签为 "1.0"的镜像：
```
docker build -t my-nginx:1.0 .   （不要少了点“.”），其中-t 选项为镜像设置名称和标签
```
（6）运行镜像
```
docker run -d -p 80:80 my-nginx:1.0    其中-d 选项用于指定容器以后台模式运行
```

## 2、Docker容器相关的命令
（1）列出正在运行的容器

     docker ps
（2）列出所有容器（包括停止的容器）

    docker ps -a
（3）创建并运行容器 

    docker run -d -p 8080:80 --name my-container ubuntu
（4）进入某个正在运行的容器 docker exec -it <容器ID或名称> <命令>
       
    docker exec -it my-container /bin/bash
       
（5）停止容器 docker stop <容器ID或名称> 
           
    docker stop my-container
        
（6）启动容器 docker start <容器ID或名称>
        
    docker start my-container

（7）删除容器 docker rm <容器ID或名称>

    docker rm my-container

（8）查看容器日志 docker logs <容器ID或名称>  

    docker logs my-container
（9）复制文件到容器中 docker cp <本地文件路径> <容器ID或名称>:<容器目标路径>
	
	docker cp local-file.txt my-container:/app/
	

## 3、Dockerfile常用的相关指令
>Dockerfile是用于定义Docker镜像构建过程的文本文件，其中包含了一系列指令，用于指定构建镜像所需的操作和配置。

    FROM：指定基础镜像，即从哪个镜像开始构建。通常是一个官方的基础镜像，如ubuntu、alpine等
    RUN：在镜像中执行命令。可以使用RUN指令运行任意的Shell命令或者其他可执行文件
    COPY：将主机的文件或目录复制到镜像中指定的路径
    WORKDIR：设置工作目录，即在容器中运行命令时的当前目录
    ENV：设置环境变量，用于在容器中设置常用的环境配置
    EXPOSE：声明容器运行时需要监听的端口号
    CMD：指定容器启动后要执行的命令。可以有多个CMD指令，但只有最后一个会生效
    VOLUME：声明容器中的挂载点，用于持久化存储数据或与宿主机共享数据

示例：通过使用这个Dockerfile，可以构建一个包含Apache2和PHP的Ubuntu镜像，并将应用程序文件index.php复制到镜像中。
```docker
# 使用最新版Ubuntu作为基础镜像
FROM ubuntu:latest

# 设置作者信息
LABEL maintainer="Your Name <your-email@example.com>"

# 更新系统并安装了Apache2、PHP及其它相关软件包。
# &&符号用于连接多个命令，rm -rf /var/lib/apt/lists/*用于清理APT包管理器的缓存。
RUN apt-get update && apt-get install -y \
    apache2 \
    php7.4 \
    libapache2-mod-php7.4 \
    && rm -rf /var/lib/apt/lists/*

# 将index.php文件从主机复制到容器的/var/www/html/目录中
COPY index.php /var/www/html/

# 设置了工作目录为/var/www/html，这意味着在容器中运行命令时的当前目录将是该目录。
WORKDIR /var/www/html

# 声明了容器运行时需要监听的端口号，这里是80端口，用于提供Web服务
EXPOSE 80

# 使用CMD指令设置了容器启动后要执行的命令，这里是运行Apache2作为前台进程来启动Web服务
# 通过在CMD指令中指定apache2ctl -D FOREGROUND，容器启动时Apache进程将以前台模式运行，以防止容器退出，并持续输出日志信息到终端，使得容器保持运行状态。这样，当我们在后台运行容器时，可以通过查看终端输出来监视Apache服务器的运行情况和调试信息。
CMD ["apache2ctl", "-D", "FOREGROUND"]

```

## 4、docker-compose常用的相关命令
```
docker-compose up：启动和创建所有在docker-compose.yml文件中定义的服务。如果需要，会自动构建镜像。容器将在前台运行，并将日志输出到当前终端。
docker-compose up -d：与上述命令相同，但容器将在后台运行，不会在当前终端输出日志。
docker-compose down：停止和删除所有在docker-compose.yml文件中定义的服务。相关的容器、网络和卷将被删除。
docker-compose ps：列出当前正在运行的容器，显示容器的状态。
docker-compose logs：显示所有服务容器的日志输出。默认情况下，输出最新的日志，并持续监视新的日志输出。
docker-compose exec <service> <command>：在正在运行的服务容器中执行命令。可以指定要执行命令的服务和要运行的命令。
docker-compose build：构建在docker-compose.yml文件中定义的服务的镜像，如果需要的话。通常在修改了Dockerfile或构建上下文后需要运行此命令。
docker-compose restart <service>：重新启动指定服务的容器。
docker-compose stop：停止所有在docker-compose.yml文件中定义的服务的容器，但不会删除它们。可以使用docker-compose start命令再次启动容器。
docker-compose rm：删除已停止的服务容器，以及相关的网络和卷。
```

>以下是一个使用Docker Compose定义的多容器应用的配置文件。该配置文件使用了版本3的Docker Compose语法。
>通过docker-compose.yml编排MySQL和Springboot项目服务以及Redis环境

    1）mysql服务名称mysql，springboot服务名称microService，Redis服务名称redis
    2）三个服务对应镜像名称mysql:5.7,redis:6.0.8,spring_test_image:1.6。参数image。
    3）三个服务容器名称mysql，redis，ms01,自定义网络docker_net参数container_name,networks
    4）三个服务端口映射mysql3306:3306，redis6379:6379，springboot8081:8081。参数ports。
    5）mysql容器数据卷/app/mysql/db:/var/lib/mysql，/app/mysql/conf/my.cnf:/etc/my.cnf，redis容器
    数据卷，/app/redis/redis.conf:/etc/redis/redis.conf，spring数据卷/app/microService:/data
    6）mysql环境environment,MYSQL_ROOT_PASSWORD=123456,springboot服务依赖redis和mysql


```yml
version: "3"  #指定了使用的Docker Compose版本
 
services: #定义了多个服务，每个服务都是一个独立的容器
  microService:
    image: spring_test_image:1.6 #使用spring_test_image:1.6镜像
    container_name: ms01 #创建一个名为ms01的容器
    ports:
      - "8081:8081" #映射主机端口8081到容器的8081端口
    volumes:
      - /app/microService:/data #将主机目录/app/microService挂载到容器内的/data目录
    networks: 
      - docker_net #将该服务连接到名为docker_net的网络
    depends_on:  #该服务依赖于redis和mysql服务。
      - redis
      - mysql
 
  redis:
    image: redis:6.0.8
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf # 将主机文件/app/redis/redis.conf挂载到容器内的/etc/redis/redis.conf文件
      - /app/redis/data:/data #将主机目录/app/redis/data挂载到容器内的/data目录
    networks: 
      -docker_net
    command: redis-server /etc/redis/redis.conf # 使用command指定容器启动时执行的命令。
 
  mysql:
    image: mysql:5.7
    container_name: mysql    
    ports:
       - "3306:3306"
    volumes: # 将主机目录挂载到容器的目录
       - /app/mysql/db:/var/lib/mysql 
       - /app/mysql/conf/my.cnf:/etc/my.cnf
       - /app/mysql/init:/docker-entrypoint-initdb.d
    networks:
      - docker_net
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问的问题
    
    environment: #设置了MySQL的环境变量，包括根密码和禁止使用空密码
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
    privileged: true
networks: 
   docker_net:  # 定义了名为docker_net的网络
```
## 5、docker的4种通信方式（了解即可）
### 容器内部通信
容器可以使用 localhost 或容器名称来进行内部通信。当多个容器运行在同一 Docker 主机上时，它们可以通过使用容器名称或 localhost 来相互访问。这种方式适用于需要容器之间直接通信的场景，例如微服务架构中的多个服务相互调用。

### 链接容器
Docker 允许将一个容器与另一个容器进行链接，使它们能够直接通信。通过链接，源容器可以访问目标容器的网络和环境变量。这种方式在较早版本的 Docker 中被广泛使用，但现在已经不推荐使用了，因为它有一些限制，并且已经有更好的替代方法

### 共享网络
Docker 允许创建自定义网络，容器可以连接到这些网络并与其他容器进行通信。在同一网络中的容器可以使用容器名称或 IP 地址进行通信。通过共享网络，容器之间可以方便地进行交互，而不受容器启动顺序的影响

### 外部主机访问
Docker 容器可以通过主机网络接口访问外部主机上的服务。通过将容器端口映射到主机端口，外部主机可以直接通过主机的 IP 地址和映射的端口与容器进行通信。这种方式适用于容器提供对外服务的情况，例如 Web 服务器容器提供 HTTP 服务。


## 6、docker推送镜像到远程镜像库DockerHub 的命令
```
docker push your-dockerhub-username/image-name:tag
```

## 7、docker commit构建镜像的步骤
### (1)运行容器。如：使用docker run命令创建容器并启动它
```
docker run -it --name my-nginx-container ubuntu:latest 

# -i   可以向容器发送输入或从容器中获取输出
# -t   为容器分配一个伪终端，类似于命令行终端的界面，使得你可以在容器中进行交互式操作
```

### (2)修改容器。如：在容器中安装Nginx
```
apt-get update
apt-get install nginx -y
```
这将更新包管理器，并安装Nginx服务器。
接下来，你可以根据需要对Nginx进行配置，例如修改Nginx的配置文件、添加网站配置等。



### (3)将容器保存为新的镜像
```
docker stop my-nginx-container # 先停止容器
docker commit my-nginx-container my-nginx-image:latest # 创建一个新的镜像，该镜像基于你刚才修改的容器
docker images # 完成镜像构建后，可以运行以下命令查看所有可用的镜像
```

## 8、Docker Registry仓库相关知识(了解即可)
>Docker Registry是Docker镜像的存储和分发系统，它用于管理和共享Docker镜像。它可以作为私有或公共的中央仓库，用于存储、组织和共享镜像。以下是与Docker Registry仓库相关的一些重要概念和知识

```
Docker Hub：Docker Hub是Docker官方提供的公共Docker Registry服务，它是最常用的Docker Registry之一。Docker Hub允许开发者将自己的镜像上传到公共仓库，并从中获取其他人共享的镜像。

私有Docker Registry：除了使用公共Docker Registry服务，你还可以搭建私有的Docker Registry来管理自己的镜像。私有Docker Registry可以在内部网络中运行，用于存储和分发组织内部使用的镜像。

仓库（Repository）：Docker Registry中的仓库是一组相关的镜像集合。仓库可以包含多个具有不同标签的镜像版本，每个标签代表一个特定的镜像。

镜像标签（Tag）：Docker镜像可以使用标签进行版本控制和标识。标签可以是数字、字母、特殊字符的组合，通常用于指示镜像的版本、日期或其他相关信息。

推送（Push）和拉取（Pull）镜像：要将本地构建的镜像上传到Docker Registry，可以使用docker push命令将镜像推送到仓库中。而要从Docker Registry获取镜像，可以使用docker pull命令从仓库中拉取镜像到本地。

镜像标识符（Image ID）：Docker镜像在Registry中具有唯一的标识符，称为镜像标识符（Image ID）。它是一个SHA-256哈希值，用于唯一标识一个镜像。

认证和访问控制：Docker Registry支持认证和访问控制，以确保只有经过授权的用户可以访问和管理镜像。这样可以保护私有镜像并限制对仓库的访问权限。

Registry镜像缓存（Registry Mirroring）：Docker Registry支持镜像缓存，通过配置多个Registry镜像来提高镜像的分发性能和可靠性。
```

## 9、Docker的数据卷作用和特征
```
(1)数据卷（DataVolumes）是宿主机中的一个目录或文件，与容器内的目录或文件进行关联。数据卷的设计目的就是数据的持久化，与容器相比，数据卷的生命周期更长，即使容器停止或删除，数据卷中的数据仍然存在。
(2)特点：数据卷可以在容器之间共享和重用，本地与容器间传递数据更高效;
对数据卷的内容修改会立马有效，在容器内部与本地目录均可对数据卷内容进行修改，对数据卷的更新不会影响镜像，对数据与应用进行了解耦操作;
卷会一直存在，直到没有容器使用
(3)挂载数据卷的语法：（--privileged=true：授予容器特权，允许执行敏感操作。）
docker run -it  -v /宿主机绝对路径目录:/容器内目录 --privileged=true 镜像
```

## 10、docker networt
### 网络相关命令
docker network ls：列出所有的Docker网络。这个命令将显示所有已创建的网络，并提供网络ID、名称、驱动程序和作用域等信息。
```
docker network ls
```

docker network create：创建一个新的Docker网络。使用该命令可以创建自定义的网络，并指定网络的名称、驱动程序、子网等参数。
```
docker network create <network_name>
```

docker network inspect：查看Docker网络的详细信息。可以通过网络名称或网络ID来指定要检查的网络。
```
docker network inspect <network_name>
```
docker network connect：将容器连接到指定的网络。可以将一个或多个容器连接到现有的网络。
```
docker network connect <network_name> <container_name_or_id>
```
docker network disconnect：断开容器与指定网络的连接。将容器与特定网络的连接断开
```
docker network disconnect <network_name> <container_name_or_id>
```
docker network rm：删除一个或多个Docker网络。可以通过网络名称或网络ID来指定要删除的网络。
```
docker network rm <network_name>
```

docker network prune：清理不再使用的Docker网络。这个命令将删除未被任何容器使用的网络
```
docker network prune
```



### 网络的作用
```
容器间通信：网络允许在不同的Docker容器之间进行通信和数据交换。容器可以通过网络相互发送请求、共享数据和进行协作，实现应用程序的分布式架构。

服务发现和负载均衡：通过网络，容器可以注册自己的服务，并让其他容器或外部服务发现和访问。网络还可以提供负载均衡的功能，将请求分发给多个容器实例，以提高应用程序的可扩展性和性能。

隔离和安全性：Docker网络提供了一定程度的隔离和安全性。不同的网络可以将容器分组在不同的逻辑网络中，使得容器间的通信受到限制。网络还可以实现访问控制和防火墙规则，保护容器和应用程序的安全性。

主机与容器间的通信：Docker网络使得主机与容器之间可以进行通信。这使得容器可以与主机上的其他服务或资源进行交互，例如访问主机的文件系统、日志或配置文件。

跨主机通信：Docker网络可以连接不同主机上的容器，实现跨主机的通信和协作。这使得容器可以在分布式环境中相互通信，构建复杂的应用程序和服务架构。

网络插件和驱动程序：Docker支持不同的网络插件和驱动程序，使得可以使用各种网络技术和协议。例如，Docker提供了bridge网络驱动程序、overlay网络驱动程序等，还可以使用第三方插件如Flannel、Calico等，以满足特定的网络需求。
```


### 网络模式
```
(1)Bridge：为每一个容器分配ip，并且将容器连接到docker0网桥，默认为该模式。使用--network bridge指定，默认使用docker0网卡。
如：Docker run -d -it --name=u1 ubuntu:latest /bin/bash
(2)Host：容器不会虚拟出自己的网卡，配置自己的ip等，而是使用宿主机的ip和端口。--network host，
如：docker run -d -it --network host --name tomcat83 tomcat8-jdk8
(3)None：容器有独立的网络命名空间，但是没有对其进行设置任何网络设置，如分配veth pair（虚拟以太网设备对）和网桥连接，ip等。在"none"网络模式下，容器与主机完全隔离，无法进行网络通信。这种模式适用于那些不需要网络连接的容器，或者需要手动配置网络的特殊情况。  --network none
如：docker run -d -p 8084:8080 --network none --name tomcat84 tomcat8-jdk8
(4)Container：新创建的容器不会创建自己的网卡和配置自己的ip，而是和一个指定的容器共享ip，端口范围等。--network container：name或者容器id指定
```


## 11、docker run相关操作
```
docker run -d -p 3310:3306 --privileged=true\
-v  /root/mysql/log:/var/log/mysql\
-v  /root/mysql/data:/var/lib/mysql\
-v  /root/mysql/conf:/etc/mysql/conf.d\
-e  MYSQL_ROOT_PASSWORD=123456\
--name  mysql5.7\
mysql:5.7
```


## 12、docker的5个组成部分（组件）
`(1)Docker客户端-Client`

`(2)Docker服务器-Dockerdaemon ——  Docker守护进程`

`(3)Docker镜像-Image`

`(4)Docker注册表（Registry）—— 镜像中央仓库`

`(5)Docker容器-Container`


>5个组件之间的关联

```
Docker Daemon（Docker守护进程）和Docker Client（Docker客户端）：
Docker守护进程和Docker客户端之间通过API进行通信。Docker客户端发送命令和请求给守护进程，守护进程接收并处理这些命令，并返回相应的结果给客户端。通过这种通信方式，用户可以与守护进程进行交互，管理和控制Docker容器、镜像和其他资源。

Docker镜像（Docker Image）和Docker容器（Docker Container）：
Docker镜像是用于创建Docker容器的模板。镜像包含了应用程序的代码、运行时、依赖项和配置等信息。每个容器都是基于相应的镜像创建的独立运行环境，可以具有不同的配置和状态。

Docker容器（Docker Container）和Docker Daemon（Docker守护进程）：
Docker容器是由Docker守护进程创建、管理和监控的。守护进程负责容器的生命周期，包括创建、启动、停止、删除和销毁等操作。守护进程还负责分配资源给容器，管理容器的网络和存储卷，并监控容器的运行状态。

Docker镜像（Docker Image）和Docker注册表/中央仓库（Docker Registry）：
Docker镜像可以从中央仓库中拉取到本地主机，也可以将自己创建的镜像推送到中央仓库中。中央仓库是存储和分发镜像的存储库，用户可以通过中央仓库共享和获取镜像。当需要在新的环境中运行应用程序时，可以通过从中央仓库中拉取相应的镜像来创建Docker容器。

Docker Daemon（Docker守护进程）和Docker注册表/中央仓库（Docker Registry）：
Docker守护进程通过网络连接到Docker中央仓库来获取镜像。当用户通过命令请求拉取镜像时，守护进程将向中央仓库发出请求，下载镜像到本地主机。同样地，当用户推送自己创建的镜像时，守护进程会将镜像上传到中央仓库中，以便其他用户可以访问和使用。
```




`容器启动过程如下：`
```
Docker客户端执行docker run命令；
Docker守护进程Docker daemon发现本地没有httpd镜像；
daemon会从DockerHub（默认的公共镜像注册表）下载镜像；
下载完成，镜像httpd被保存到本地；
Docker daemon启动容器。
Registry是存放Docker镜像的仓库，Registry分私有和公有两种；
DockerHub（https://hub.docker.com/）是默认的Registry，由Docker公司维护，上面有数以万计的镜像，用户可以自由下载和使用；
Docker容器就是Docker镜像的运行实例，可将Docker镜像看做只读模板，通过它可以创建Docker容器；将镜像的内容和创建步骤描述在一个文本文件中，这个文件被称作Dockerfile，通过执行docker build <docker-file> 命令可以构建出Docker镜像；
Docker daemon是服务器组件，以Linux后台服务的方式运行，Docker daemon运行在Docker host上，负责创建、运行、监控容器，构建、存储镜像；
最常用的Docker客户端是docker命令。通过docker我们可以方便地在Host上构建和运行容器；除了docker命令行工具，用户也可以通过RESTAPI与服务器通信。
```



# 补充
## Docker简介
`Docker 是一个开源的应用容器引擎，基于 Go 语言， 并遵从 Apache2.0 协议开源。`

`Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，这个容器可以在不同的环境中运行，提供了更高的灵活性和可移植性，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。`

## Docker的应用场景
* Web 应用的自动化打包和发布。
* 自动化测试和持续集成、发布。
* 在服务型环境中部署和调整数据库或其他的后台应用。

## Docker的前身（Linux容器）—— LXC
与传统虚拟化技术相比，它的优势在于：

`1、LXC容器更加轻量级、启动速度更快`

`2、与宿主机使用同一个内核，不需要额外的操作系统，性能损耗小`

`3、对系统资源的利用更高效`

`4、不需要指令级模拟`

`5、不需要即时编译`

`6、容器可以在CPU核心的本地运行指令，不需要任何专门的解释机制`

`7、避免了准虚拟化和系统调用替换中的复杂性`

`8、轻量级隔离，在隔离的同时还提供共享机制，以实现容器与宿主机的资源共享`


## Docker与前身（Linux容器）—— LXC的关系
`1、docker并不是LXC替代品，早期版本的docker底层使用了LXC来实现`

`2、随着发展，Docker引入了自己的容器运行时libcontainer，并逐渐摆脱了对LXC的直接依赖。libcontainer是一个纯粹的Go语言实现，提供了更高级别的容器抽象和管理功能。`

`3、与LXC相比，Docker引入了容器镜像的概念，并提供了更便捷的容器镜像管理和分发机制`


## Docker与虚拟机
```
1、传统虚拟机是基于Hypervisor的虚拟化技术，它在物理主机上创建一个或多个虚拟机，每个虚拟机运行独立的操作系
统。每个虚拟机都包含一个完整的操作系统和应用程序堆栈。而Docker采用容器化技术，将应用程序及其依赖项打包到
一个容器中，并在宿主机的操作系统上共享内核。容器之间相互隔离，但共享操作系统内核，从而实现更高的性能和
资源利用率。

2、传统虚拟机运行时需要为每个虚拟机分配独立的操作系统和虚拟硬件资源，包括CPU、内存和存储等。这使得传统虚
拟机的资源消耗较高。相比之下，Docker容器共享宿主机的操作系统和内核，容器之间的资源隔离更轻量级，启动和
停止容器也更快速。这使得Docker在资源利用和性能方面具有优势。

3、传统虚拟机的部署和管理通常需要额外的虚拟机管理软件和工具，例如VMware等。管理员需要管理和维护多个虚拟
机的状态和配置。而Docker提供了简单易用的容器管理工具，例如Docker Engine、Docker Compose等。通过这些
工具，用户可以更方便地创建、部署、扩展和管理容器化应用程序。

4、传统虚拟机适用于需要在不同操作系统之间进行隔离和虚拟化的场景，如多租户云环境、完全隔离的测试和开发环
境等。而Docker更适合构建和部署轻量级、可移植的应用程序。它在开发、持续集成和交付、微服务架构等方面具有
广泛的应用场景。
```

## Docker容器
>Docker容器是Docker技术的核心概念之一。它是一种轻量级的虚拟化技术，用于打包应用程序及其所有依赖项，并提供一个独立、可移植和可隔离的运行环境。

>容器不是模拟一个完整的操作系统，而是对进程进行分组隔离。有了容器，就可以将软件运行所需的所有资源打包到一个隔离的环境中。

>容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件工作所需的库资源和设置。

## Docker镜像
>Docker镜像就是一个只读模板，提供容器运行所需的文件系统。文件系统包含运行应用程序所需的一切——所有依赖项、配置、脚本、二进制文件等。镜像还包含容器的其他配置，例如环境变量、要运行的默认命令、和其他元数据。



# 实验
`要求：使用下面的所有命令，并且保留 CMD 的截图，需要将截图放到实验报告中。`

## docker images

查看本地下载的镜像

```sh
docker images
```
## docker search

搜索对应的镜像列表

```sh
docker search <镜像名称>
```
## docker rmi

删除镜像

```sh
docker rmi <镜像名称>
```

## docker pull

下载（拉取）对应的镜像

```sh
docker pull <镜像名称:版本>
```

## docker ps

查看本地运行的容器有哪些

```sh
docker ps
```

## docker run -d

使用指定的镜像创建一个容器并运行

```sh
docker run -d --name=<容器的名称> <镜像名称:版本>
```

## docker exec -it

进入某个正在运行的容器

```sh
docker exec -it <容器的名称|id> </bin/bash>|</bin/sh>
```

## docker start

启动指定的容器

```sh
docker start <容器的名称1|id1> <容器的名称2|id2> ...
```

## docker restart

启动指定的容器

```sh
docker restart <容器的名称1|id1> <容器的名称2|id2> ...
```

## docker stop

启动指定的容器

```sh
docker stop <容器的名称1|id1> <容器的名称2|id2> ...
```

## docker rm

删除容器

```sh
docker rm <容器的名称1|id1> <容器的名称2|id2> ...
```

## docker network ls

查看已有的网络

```sh
docker network ls
```

## docker network create

创建网络

```sh
docker network create --driver="bridge" <网络的名字>
```

## docker network rm

删除指定的网络

```sh
docker network rm <网络的名字>
```

## docker port 

查看容器端口

```sh
docker port <容器的名称1|id1> <容器的名称2|id2> ...
```

## docker inspect

查看容器的所有信息

```sh
docker inspect <容器的名称1|id1> <容器的名称2|id2> ...
```