浅小兮

Docker命令-卷命令

2025-04-20T02:10:10.000Z

docker volume 命令

docker volume 命令用于管理 Docker 卷（volume）。卷是用于持久化数据的文件系统，可以在容器之间共享和重用。通过使用卷，数据可以在容器停止或删除时仍然保留。

常用 `docker volume` 命令

docker volume ls: 列出所有卷
docker volume inspect: 查看卷的详细信息
docker volume create: 创建一个新卷
docker volume rm: 删除一个或多个卷
docker volume prune: 删除未使用的卷

`docker volume ls` 命令

列出所有卷。

docker volume ls

输出：

1
2
3

DRIVER              VOLUME NAME
local               my_volume
local               another_volume

docker volume inspect 命令

查看指定卷的详细信息。

docker volume inspect my_volume

输出：

[
    {
        "CreatedAt": "2024-07-23T00:00:00Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my_volume/_data",
        "Name": "my_volume",
        "Options": {},
        "Scope": "local"
    }
]

docker volume create 命令

创建一个新卷。

docker volume create my_volume

常用参数

--driver: 指定卷驱动程序（默认为 local）。
--label: 为卷添加标签。
-o, --opt: 为卷指定驱动程序选项。

示例：

docker volume create --name my_volume --label project=my_project

docker volume rm 命令

删除一个或多个卷。

docker volume rm my_volume

删除多个卷：

docker volume rm volume1 volume2

docker volume prune 命令

删除未使用的卷。

docker volume prune

使用场景

持久化数据: 卷用于持久化数据，即使容器被删除，数据仍然保留。
共享数据: 卷可以在多个容器之间共享数据。
备份和恢复: 卷可以用于备份和恢复容器数据。
分离数据和应用: 卷使数据和应用程序分离，便于管理和迁移。

docker volume 命令集提供了强大的数据管理功能，允许用户创建、配置和管理 Docker 卷。通过使用这些命令，用户可以实现数据的持久化、共享和备份，满足各种数据管理需求。

Docker命令-网络命令

2025-04-01T02:10:10.000Z

docker network 命令

docker network 命令用于管理 Docker 网络。这些命令可以创建、列出、删除和检查网络，帮助用户在 Docker 容器之间建立通信。

常用 `docker network` 命令

docker network ls: 列出所有网络
docker network inspect: 查看网络详细信息
docker network create: 创建一个新网络
docker network rm: 删除一个或多个网络
docker network connect: 将一个容器连接到一个网络
docker network disconnect: 将一个容器从一个网络断开

`docker network ls` 命令

列出所有网络。

docker network ls

输出：

NETWORK ID          NAME                DRIVER              SCOPE
b649b57f5bc5        bridge              bridge              local
7e8c2d2c0b5a        host                host                local
6a9c8d69bfb2        none                null                local

`docker network inspect` 命令

查看指定网络的详细信息。

输出：

[
    {
        "Name": "my_network",
        "Id": "b649b57f5bc5",
        "Created": "2024-07-23T00:00:00.000000000Z",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "172.18.0.0/16",
                    "Gateway": "172.18.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

`docker network create` 命令

创建一个新网络。

docker network create my_network

常用参数

--driver: 指定网络驱动程序（如 bridge、host、overlay）。
--subnet: 指定子网。
--gateway: 指定网关。
--ip-range: 指定可用 IP 地址范围。
--ipv6: 启用 IPv6。
--label: 为网络添加标签。

示例：

docker network create --driver bridge --subnet 192.168.1.0/24 my_network

`docker network rm` 命令

删除一个或多个网络。

docker network rm my_network

删除多个网络：

docker network rm network1 network2

`docker network connect` 命令

将一个容器连接到一个网络。

docker network connect my_network my_container

`docker network disconnect` 命令

将一个容器从一个网络断开。

docker network disconnect my_network my_container

使用场景

容器间通信: 通过自定义网络，容器可以在不同主机上安全地相互通信。
隔离环境: 使用不同的网络来隔离容器环境，提高安全性。
高级网络配置: 使用桥接、覆盖等网络驱动程序实现复杂的网络拓扑结构。

docker network 命令集提供了强大的网络管理功能，允许用户创建、配置和管理 Docker 容器之间的网络连接。通过使用这些命令，用户可以实现容器之间的隔离、通信和网络配置，满足各种复杂的网络需求。

Docker命令-Docker Compose

2025-03-28T02:10:10.000Z

docker compose run 命令

docker compose run 命令用于启动一个新容器并运行一个特定的服务，而不启动整个 Compose 文件中定义的所有服务。

docker compose run 命令允许你在单个服务上执行任务，如运行一次性命令或调试。

与 docker compose up 的区别在于，run 命令只会运行指定的服务，不会启动依赖它的其他服务。

语法

docker compose run [OPTIONS] SERVICE [COMMAND] [ARGS...]

SERVICE：Compose 文件中定义的服务名称。
COMMAND 和 ARGS：可选参数，指定要在容器内运行的命令及其参数。

OPTIONS 选项：

--rm：运行后自动删除容器。
-d：以分离模式运行容器。
-T：禁用伪TTY。

实例

1、运行一个特定服务的命令

docker compose run web python manage.py migrate

这个命令将在 web 服务的容器中执行 python manage.py migrate 命令，而不启动其他服务。

2、自动删除容器

docker compose run --rm web bash

这个命令会运行 web 服务并启动一个 Bash 终端，任务完成后会删除容器。

docker compose run 非常适合用来在服务中执行一次性任务，而不影响其他服务的运行。

docker compose rm 命令

docker compose rm 命令用于删除已停止的服务容器。

docker compose rm 命令不会删除运行中的容器，主要用于清理已停止或不再需要的容器，以释放系统资源。

语法

docker compose rm [OPTIONS] [SERVICE...]

SERVICE（可选）：要删除的服务容器的名称。如果不指定服务名称，将删除所有已停止的服务容器。

OPTIONS 选项：

-f, --force：强制删除容器，而不提示用户确认。
-s, --stop：首先停止正在运行的容器，然后删除它们。
-v, --volumes：同时删除与容器关联的卷（volume）。

实例

1、删除所有已停止的服务容器

docker compose rm

会列出并提示是否删除所有停止的服务容器。

2、强制删除所有已停止的服务容器

docker compose rm -f

直接删除停止的容器，不会提示用户确认。

3、删除特定服务的已停止容器

docker compose rm web

仅删除 web 服务的已停止容器。

4、删除并清理相关卷

docker compose rm -v

删除已停止的容器并同时删除与之关联的卷。

docker compose ps 命令

docker compose ps 命令用于列出与 Docker Compose 项目相关的容器及其状态。

docker compose ps 能显示当前项目中所有服务容器的运行状态、端口映射等信息。

语法

docker compose ps [OPTIONS] [SERVICE...]

SERVICE（可选）：指定要查看状态的服务名称。如果不指定，将列出所有服务的容器状态。

OPTIONS 选项：

-a, --all：列出所有容器，包括已停止的容器。
-q, --quiet：仅显示容器 ID，不显示其他信息。
--services：仅列出服务名称，不显示容器的详细信息。
--filter：根据条件过滤输出结果。例如，可以按照状态过滤容器。

输出信息

Name：容器名称。
Command：容器中运行的命令。
State：容器的状态（如 Up、Exited）。
Ports：容器的端口映射。

实例

1、列出所有运行中的容器

docker compose ps

显示当前项目中正在运行的容器及其状态。

2、列出所有容器（包括已停止的容器）

docker compose ps -a

包括停止的容器在内，列出所有容器的状态。

3、仅显示容器 ID

docker compose ps -q

只返回容器的 ID，不包括其他详细信息。

4、列出所有服务的名称

docker compose ps --services

只显示服务名称，而不列出容器的详细信息。

5、根据状态过滤容器

docker compose ps --filter "status=running"

仅列出状态为"running"的容器。

docker compose build 命令

docker compose build 命令用于根据 docker-compose.yml 文件中的定义，构建服务的镜像。

docker compose build 会从指定的 Dockerfile 或 build 上下文中构建镜像，并为所有服务准备好容器。

语法

docker compose build [OPTIONS] [SERVICE...]

SERVICE（可选）：指定要构建的服务名称。如果不指定，将为所有服务构建镜像。

OPTIONS 选项：

--no-cache：在构建过程中不使用缓存层，强制从头开始构建镜像。
--pull：始终尝试从注册表中拉取最新的基础镜像。
--build-arg：传递构建时的变量（类似于 Docker 的 --build-arg 选项）。
--progress：指定构建的进度样式（auto、plain、tty），影响显示的输出方式。
--parallel：并行构建多个服务镜像以提高速度。
--no-rm：构建失败时，保留中间容器（默认在成功或失败后都会删除中间容器）。

实例

1、为所有服务构建镜像

docker compose build

根据 docker-compose.yml 中的配置，为所有服务构建镜像。

2、构建特定服务的镜像

docker compose build web

仅为 web 服务构建镜像。

3、不使用缓存构建镜像

docker compose build --no-cache

强制 Docker 从头构建所有镜像，不使用之前构建的缓存层。

4、从最新基础镜像构建

docker compose build --pull

确保 Docker 拉取最新的基础镜像，而不是使用本地镜像。

5、传递构建变量

docker compose build --build-arg NODE_ENV=production

通过 --build-arg 传递构建时所需的变量，例如传递 NODE_ENV 环境变量。

docker compose up 命令

docker compose up 命令用于启动 Docker Compose 项目中定义的所有服务容器，并确保它们按照 docker-compose.yml 文件中的配置运行。

docker compose up 命令不仅会启动服务，还会自动构建尚未构建的镜像（如有必要），创建网络和卷，并以容器的形式启动服务。

语法

docker compose up [OPTIONS] [SERVICE...]

SERVICE（可选）：可以指定一个或多个服务，仅启动这些服务。如果不指定，将启动所有服务。

OPTIONS 选项：

-d, --detach：以后台模式运行容器，类似于在 docker run 中使用 -d 选项。
--build：在启动之前强制重新构建镜像，即使镜像已存在。
--no-build：阻止在启动时构建镜像，即使镜像不存在也不构建。
--force-recreate：强制重新创建容器，即使它们已经存在且内容未发生变化。
--no-recreate：如果容器已经存在，则不重新创建它们（默认行为是如果配置文件变化则重新创建）。
--remove-orphans：移除不再在 Compose 文件中定义的孤立容器。
-V, --renew-anon-volumes：重新创建匿名卷（删除旧的卷并创建新的）。

实例

1、启动所有服务并附加到控制台

docker compose up

启动 Compose 文件中定义的所有服务，并将日志输出显示在当前终端中。

2、在后台模式运行服务

docker compose up -d

以后台（分离）模式运行所有服务，终端不会输出服务的日志。

3、仅启动指定服务

docker compose up web

只启动 web 服务，而不启动其他服务。

4、启动服务并强制重建镜像

docker compose up --build

在启动服务之前，强制重新构建服务镜像。

5、启动服务并强制重新创建容器

docker compose up --force-recreate

强制重新创建服务容器，即使之前的容器存在且未发生更改。

6、启动服务并移除不再存在于 Compose 文件中的孤立容器

docker compose up --remove-orphans

移除任何不再在当前 docker-compose.yml 文件中定义的容器。

docker compose ls 命令

docker compose ls 命令用于列出当前系统中所有 Docker Compose 项目及其状态。

docker compose ls 命令可以帮助你快速查看有哪些 Compose 项目正在运行或处于其他状态。

语法

docker compose ls [OPTIONS]

OPTIONS 选项：

--all：显示所有项目，包括未启动的项目。
--filter：根据条件过滤输出结果。例如，可以按状态过滤。
--format：指定输出格式（如 table、json 等）。
--quiet：只显示项目名称，而不显示其他信息。

输出信息：

docker compose ls 的输出信息包括以下字段：

Name：项目名称。
Status：项目的状态（例如 running、exited 等）。
Config Files：与项目相关联的 docker-compose.yml 文件的路径。

实例

1、列出所有运行的 Docker Compose 项目

docker compose ls

显示当前正在运行的所有项目及其状态。

2、列出所有项目（包括未启动的）

docker compose ls --all

显示包括未启动的项目在内的所有 Compose 项目。

3、仅显示项目名称

docker compose ls --quiet

只返回项目名称，而不包括详细信息。

4、按状态过滤项目

docker compose ls --filter "status=running"

仅显示状态为 running 的项目。

docker compose start 命令

docker compose start 命令用于启动已存在但目前处于停止状态的 Docker Compose 服务容器。

与 docker compose up 不同，它不会创建新的容器或重新构建镜像，只会启动已经创建但停止的容器。

语法

docker compose start [SERVICE...]

SERVICE（可选）：指定要启动的服务名称。如果不指定，将启动所有已停止的服务容器。

实例

1、启动所有已停止的服务

docker compose start

这将启动所有当前处于停止状态的容器。

2、启动特定服务

docker compose start web

仅启动 web 服务的容器，而不影响其他服务。

docker compose restart 命令

docker compose restart 命令命令用于重启一个或多个服务。

与 docker compose restart 命令会停止正在运行的服务容器，然后重新启动它们。

如果你需要更新配置或者只是想简单地重启服务而不需要重建容器，那么 restart 是很有用的。

语法

docker compose restart [SERVICE...]

SERVICE（可选）：可以指定要重启的一个或多个服务名称。如果不指定服务名称，则会重启所有在 docker-compose.yml 文件中定义的服务。

实例

1、重启所有服务：

docker-compose restart

2、重启特定的服务（例如名为 web 和 db 的服务）：

docker-compose restart web db

确保你在包含 docker-compose.yml 文件的目录中执行这些命令，或者通过 -f 参数指定 docker-compose.yml 文件的位置。例如，如果你的 docker-compose.yml 文件不在当前目录下，你可以这样指定文件位置：

docker-compose -f /path/to/docker-compose.yml restart

这样做可以让你控制哪个 docker-compose.yml 文件被用来管理服务。

Docker命令-info_version

2025-03-15T02:10:10.000Z

docker info 命令

docker info 命令用于显示 Docker 系统的详细信息，包括 Docker 版本、存储驱动、镜像数量、容器数量以及其他重要的配置信息。

docker info 命令非常有用，可以帮助用户了解 Docker 环境的总体状态。

语法

docker info [OPTIONS]

实例

查看docker系统信息。

$ docker info
Client:
 Context:    default
 Debug Mode: false
 Plugins:
  buildx: Docker Buildx (Docker Inc., 0.8.1)
  compose: Docker Compose (Docker Inc., 2.3.3)

Server:
 Containers: 3
  Running: 1
  Paused: 0
  Stopped: 2
 Images: 10
 Server Version: 20.10.7
 Storage Driver: overlay2
  Backing Filesystem: extfs
  Supports d_type: true
  Native Overlay Diff: true
 Logging Driver: json-file
 Cgroup Driver: cgroupfs
 Cgroup Version: 1
 Plugins:
  Volume: local
  Network: bridge host ipvlan macvlan null overlay
  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog
 Swarm: inactive
 Runtimes: runc
 Default Runtime: runc
 Init Binary: docker-init
 containerd version: d71fcd7d8303cbf684402823e425e9dd2e99285d
 runc version: b9ee9c6314599f1b4a7f497e1f1f856fe433d3b7
 init version: de40ad0
 Security Options:
  seccomp
   Profile: default
  selinux
 Kernel Version: 5.10.25-linuxkit
 Operating System: Docker Desktop
 OSType: linux
 Architecture: x86_64
 CPUs: 2
 Total Memory: 1.942GiB
 Name: docker-desktop
 ID: 3WZ2:ZQ7K:6K4E:6ZCR:YITZ:GH2S:6NUB:HTB5:OS7K:AAUI:K7CC:JZL3
 Docker Root Dir: /var/lib/docker
 Debug Mode: true
  File Descriptors: 45
  Goroutines: 49
  System Time: 2024-07-23T09:41:47.2527914Z
  EventsListeners: 4
 HTTP Proxy: http://proxy.example.com:80
 HTTPS Proxy: https://proxy.example.com:443
 No Proxy: localhost,127.0.0.1,docker-registry.example.com
 Registry: https://index.docker.io/v1/
 Labels:
 Experimental: false
 Insecure Registries:
  127.0.0.0/8
 Registry Mirrors:
 Live Restore Enabled: false

WARNING: No swap limit support

输出解释

Client: Docker 客户端的相关信息。

Context: 当前 Docker 上下文。
Debug Mode: 客户端是否开启调试模式。
Plugins: 安装的客户端插件，如 buildx 和 compose。

Server: Docker 服务端（守护进程）的相关信息。

Containers: 容器的总数。
- Running: 运行中的容器数量。
- Paused: 暂停中的容器数量。
- Stopped: 停止的容器数量。
Images: 镜像的总数。
Server Version: Docker 服务端的版本号。
Storage Driver: 使用的存储驱动（如 overlay2）。
Backing Filesystem: 后端文件系统类型。
Supports d_type: 是否支持 d_type。
Native Overlay Diff: 是否支持原生 Overlay 文件系统。
Logging Driver: 使用的日志驱动（如 json-file）。
Cgroup Driver: 使用的 Cgroup 驱动（如 cgroupfs）。
Cgroup Version: Cgroup 的版本（如 1）。
Plugins: 服务端插件列表，包括卷、网络和日志插件。
Swarm: Swarm 模式的状态（如 inactive）。
Runtimes: 支持的运行时（如 runc）。
Default Runtime: 默认运行时（如 runc）。
Init Binary: 初始化二进制文件（如 docker-init）。
containerd version: 使用的 containerd 版本。
runc version: 使用的 runc 版本。
init version: 使用的 init 版本。
Security Options: 启用的安全选项（如 seccomp 和 selinux）。
Kernel Version: 内核版本。
Operating System: 操作系统名称。
OSType: 操作系统类型（如 linux）。
Architecture: 系统架构（如 x86_64）。
CPUs: CPU 数量。
Total Memory: 总内存。
Name: Docker 主机名。
ID: Docker 实例 ID。
Docker Root Dir: Docker 根目录。
Debug Mode: 服务端是否开启调试模式。
- File Descriptors: 文件描述符数量。
- Goroutines: Goroutines 数量。
- System Time: 系统时间。
- EventsListeners: 事件监听器数量。
HTTP Proxy: 配置的 HTTP 代理。
HTTPS Proxy: 配置的 HTTPS 代理。
No Proxy: 不使用代理的地址列表。
Registry: 使用的注册表地址。
Labels: 配置的标签。
Experimental: 是否启用了实验性功能。
Insecure Registries: 配置的不安全注册表列表。
Registry Mirrors: 注册表镜像列表。
Live Restore Enabled: 是否启用了实时恢复功能。

WARNING: 警告信息（如没有启用 swap 限制支持）。

docker version 命令

docker version 命令用于显示 Docker 客户端和服务端的版本信息。

docker version 命令可以帮助你确认当前安装的 Docker 版本以及客户端和服务器的详细版本信息。

另外还有一个 docker --version 命令是用于显示 Docker 的版本信息。

语法

docker version [OPTIONS]

OPTIONS说明：

-f :指定返回值的模板文件。

实例

显示 Docker 版本信息。

$ docker version
Client: Docker Engine - Community
 Version:           20.10.7
 API version:       1.41
 Go version:        go1.13.15
 Git commit:        f0df350
 Built:             Wed Jun  2 11:57:37 2021
 OS/Arch:           linux/amd64
 Context:           default
 Experimental:      true

Server: Docker Engine - Community
 Engine:
  Version:          20.10.7
  API version:      1.41 (minimum version 1.12)
  Go version:       go1.13.15
  Git commit:       b0f5bc3
  Built:            Wed Jun  2 11:55:47 2021
  OS/Arch:          linux/amd64
  Experimental:     false
 containerd:
  Version:          1.4.6
  GitCommit:        d71fcd7d8303cbf684402823e425e9dd2e99285d
 runc:
  Version:          1.0.0-rc95
  GitCommit:        b9ee9c6314599f1b4a7f497e1f1f856fe433d3b7
 docker-init:
  Version:          0.19.0
  GitCommit:        de40ad0

输出解释

Client: Docker 客户端的相关信息。

Version: 客户端的版本号。
API version: API 的版本号。
Go version: 编译 Docker 客户端所用的 Go 语言版本。
Git commit: 该版本对应的 Git 提交 ID。
Built: 构建日期。
OS/Arch: 操作系统和架构。
Context: 当前 Docker 上下文。
Experimental: 是否启用了实验性功能。

Server: Docker 服务端（守护进程）的相关信息。

Engine:
- Version: 服务端的版本号。
- API version: API 的版本号（以及支持的最低版本）。
- Go version: 编译 Docker 服务端所用的 Go 语言版本。
- Git commit: 该版本对应的 Git 提交 ID。
- Built: 构建日期。
- OS/Arch: 操作系统和架构。
- Experimental: 是否启用了实验性功能。
containerd: Docker 使用的 containerd 版本和 Git 提交 ID。
runc: Docker 使用的 runc 版本和 Git 提交 ID。
docker-init: Docker 使用的 docker-init 版本和 Git 提交 ID。

Docker命令-本地镜像管理

2025-03-03T02:10:10.000Z

Docker images 命令

docker images 命令用于列出本地的 Docker 镜像。

通过 docker images 命令，用户可以查看所有已下载或构建的 Docker 镜像的详细信息，如仓库名称、标签、镜像 ID、创建时间和大小。

语法

docker images [OPTIONS] [REPOSITORY[:TAG]]

OPTIONS 说明：

-a, --all: 显示所有镜像（包括中间层镜像）。
--digests: 显示镜像的摘要信息。
-f, --filter: 过滤输出，基于提供的条件。
--format: 使用 Go 模板格式化输出。
--no-trunc: 显示完整的镜像 ID。
-q, --quiet: 只显示镜像 ID。

列出所有本地镜像:

docker images

列出带有摘要信息的镜像:

docker images --digests

列出所有镜像（包括中间层镜像）:

docker images --all

使用过滤条件列出镜像:

docker images --filter "dangling=true"

只显示镜像 ID:

docker images --quiet

使用自定义格式输出:

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.Size}}"

实例

查看本地镜像列表:

runoob@runoob:~$ docker images
REPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
mymysql                 v1                  37af1236adef        5 minutes ago       329 MB
runoob/ubuntu           v4                  1c06aa18edee        2 days ago          142.1 MB
                                5c6e1090e771        2 days ago          165.9 MB
httpd                   latest              ed38aaffef30        11 days ago         195.1 MB
alpine                  latest              4e38e38c8ce0        2 weeks ago         4.799 MB
mongo                   3.2                 282fd552add6        3 weeks ago         336.1 MB
redis                   latest              4465e4bcad80        3 weeks ago         185.7 MB
php                     5.6-fpm             025041cd3aa5        3 weeks ago         456.3 MB
python                  3.5                 045767ddf24a        3 weeks ago         684.1 MB
...

列出本地镜像中 REPOSITORY 为 ubuntu的镜像列表:

root@runoob:~# docker images  ubuntu
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
ubuntu              14.04               90d5884b1ee0        9 weeks ago         188 MB
ubuntu              15.10               4e3b13c8a266        3 months ago        136.3 MB

带有摘要信息的输出:

docker images --digests

输出：

REPOSITORY          TAG                 DIGEST                                                                    IMAGE ID            CREATED             SIZE
ubuntu              latest              sha256:8c53f09a9c6f1e85e10a8ffb649dd9de28b9be4994e792bd96fca152527bba03   2d13d07a40a3        2 weeks ago         72.9MB
nginx               stable              sha256:1c4f40db5d1c8e5e09d28e501ad167d7c2d91b8908f6f1d9c97d1c67c5f9a69b   5a34e9e5d33b        3 weeks ago         133MB
hello-world         latest              sha256:feda4427b0b5d9d84545dcb38e736a5226e5bb6228c61b0b6b28cb7483a14b68   feb5d9fea6a5        4 weeks ago         13.3kB

使用过滤条件输出:

docker images --filter "dangling=true"

示例输出：

1 2	REPOSITORY TAG IMAGE ID CREATED SIZE 7db03500db4f 5 weeks ago 65.3MB

自定义格式输出:

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.Size}}"

输出：

REPOSITORY          TAG                 IMAGE ID            SIZE
ubuntu              latest              2d13d07a40a3        72.9MB
nginx               stable              5a34e9e5d33b        133MB
hello-world         latest              feb5d9fea6a5        13.3kB

常用场景

管理镜像: 列出本地镜像，了解当前可用的镜像。
过滤镜像: 使用过滤选项查找特定条件的镜像，如悬空镜像（未打标签的镜像）。
镜像 ID 管理: 只获取镜像 ID 以便于后续操作，如删除镜像。

docker images 命令是 Docker 镜像管理中非常基础且重要的命令。通过该命令，用户可以查看本地所有镜像的详细信息，进行镜像的管理和维护。使用各种选项和格式，可以灵活地过滤和格式化输出，以满足不同的管理需求。

Docker rmi 命令

docker rmi 命令用于删除一个或多个 Docker 镜像。

docker rmi 命令对于管理本地存储的镜像非常有用，帮助用户清理不再需要的镜像，释放存储空间。

语法

docker rmi [OPTIONS] IMAGE [IMAGE...]

参数说明：

IMAGE: 要删除的镜像的名称或 ID。可以是镜像名、镜像 ID 或镜像摘要。
OPTIONS: 可选参数，用来控制命令的行为。

常用选项：

-a, --all-tags: 指定仓库名称时，删除该仓库下的所有镜像。
-f, --force: 强制删除镜像，即使该镜像被容器使用。
--help: 打印帮助信息并退出。
--no-prune: 不删除悬空的父镜像。
-q, --quiet: 安静模式，不显示删除镜像的详细信息。

删除单个镜像

docker rmi ubuntu:latest

删除名为 ubuntu 的 latest 标签的镜像。

删除多个镜像

docker rmi ubuntu:latest nginx:latest

删除 ubuntu 和 nginx 的 latest 标签的镜像。

删除镜像的多个标签

docker rmi ubuntu:latest ubuntu:18.04

删除 ubuntu 镜像的 latest 和 18.04 标签。

删除所有标签的镜像

docker rmi -a ubuntu

删除 ubuntu 仓库下的所有镜像。

强制删除镜像

docker rmi -f ubuntu:latest

强制删除 ubuntu 的 latest 标签的镜像，即使它正在被使用。

删除悬空的镜像

docker rmi -d

删除所有没有标签的悬空镜像。

安静模式删除所有镜像

docker rmi -q $(docker images -q)

使用安静模式删除所有镜像，不显示删除的镜像信息。

删除指定仓库的所有镜像

docker rmi -a myrepo

删除 myrepo 仓库下的所有镜像。

删除镜像并保留其子镜像

docker rmi --no-prune ubuntu:latest

删除 ubuntu:latest 镜像，但保留其子镜像。

实例

查看现有镜像：

docker images

输出：

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
my_image            latest              d1e1b5a3a8a9        3 days ago          128MB
my_image1           latest              c3a4f5a3a8b8        4 days ago          256MB
my_image2           latest              a9e1d3a7c9b9        5 days ago          512MB

删除一个镜像：

docker rmi my_image

输出：

1 2	Untagged: my_image:latest Deleted: sha256:d1e1b5a3a8a9...

删除多个镜像：

docker rmi my_image1 my_image2

输出：

Untagged: my_image1:latest
Deleted: sha256:c3a4f5a3a8b8...
Untagged: my_image2:latest
Deleted: sha256:a9e1d3a7c9b9...

常用场景

清理无用镜像: 删除不再需要的镜像，以释放存储空间。
镜像管理: 管理和维护本地镜像库，确保只保留需要的镜像。
强制删除: 在镜像被容器使用时，强制删除它们（谨慎使用）。

注意事项

强制删除镜像（使用 -f 选项）时，可能会导致依赖于该镜像的容器无法运行，因此应谨慎使用。
默认情况下，docker rmi 会删除未使用的父镜像，如果不希望这样做，可以使用 --no-prune 选项。

docker rmi 命令是 Docker 镜像管理中非常重要的工具。通过该命令，用户可以删除不再需要的镜像，释放存储空间，并保持本地镜像库的整洁。使用适当的选项，可以灵活地管理镜像的删除过程。

Docker tag 命令

docker tag 命令用于创建本地镜像的别名（tag），通过为镜像打标签，可以使用更容易记忆的名字或版本号来标识和管理镜像。

语法

docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

SOURCE_IMAGE[:TAG]: 源镜像名称和标签，标签默认为 latest。
TARGET_IMAGE[:TAG]: 目标镜像名称和标签，标签默认为 latest。

1、为镜像打标签

docker tag myimage:1.0 myrepo/myimage:latest

这会将本地 myimage:1.0 镜像标记为 myrepo/myimage:latest。

2、为镜像打多个标签

1 2	docker tag myimage:1.0 myrepo/myimage:stable docker tag myimage:1.0 myrepo/myimage:v1.0

这会将 myimage:1.0 分别标记为 myrepo/myimage:stable 和 myrepo/myimage:v1.0。

3、为镜像打标签以推送到 Docker Hub

1 2	docker tag myimage:1.0 myusername/myimage:1.0 docker push myusername/myimage:1.0

这会将 myimage:1.0 镜像标记为 myusername/myimage:1.0 并推送到 Docker Hub。

实例

为镜像打标签

1、列出本地镜像

docker images

1 2	REPOSITORY TAG IMAGE ID CREATED SIZE myimage 1.0 123456789abc 2 days ago 500MB

2、为镜像打标签

docker tag myimage:1.0 myrepo/myimage:latest

3、验证标签

docker images

输出示例：

1
2
3

REPOSITORY          TAG       IMAGE ID       CREATED        SIZE
myimage             1.0       123456789abc   2 days ago     500MB
myrepo/myimage      latest    123456789abc   2 days ago     500MB

注意事项

标签只是镜像的别名，不会创建新的镜像层，因此不会占用额外的存储空间。
标签应该简洁且具有描述性，以便于识别和管理镜像版本。
在使用标签时，确保命名符合注册表的命名规范。

docker tag 命令是管理 Docker 镜像的重要工具，通过为镜像打标签，可以方便地标识、管理和发布不同版本的镜像。这个命令适用于各种场景，包括版本管理、镜像发布和镜像复制。在使用时，确保标签命名规范和描述性，以提高镜像管理的效率和可维护性。

Docker build 命令

docker build 命令用于从 Dockerfile 构建 Docker 镜像。

docker build 命令通过读取 Dockerfile 中定义的指令，逐步构建镜像，并将最终结果保存到本地镜像库中。

语法

docker build [OPTIONS] PATH | URL | -

PATH: 包含 Dockerfile 的目录路径或 .（当前目录）。
URL: 指向包含 Dockerfile 的远程存储库地址（如 Git 仓库）。
-: 从标准输入读取 Dockerfile。

常用选项：

-t, --tag: 为构建的镜像指定名称和标签。
-f, --file: 指定 Dockerfile 的路径（默认是 PATH 下的 Dockerfile）。
--build-arg: 设置构建参数。
--no-cache: 不使用缓存层构建镜像。
--rm: 构建成功后删除中间容器（默认开启）。
--force-rm: 无论构建成功与否，一律删除中间容器。
--pull: 始终尝试从注册表拉取最新的基础镜像。

更多选项说明：

--build-arg=[]: 设置构建镜像时的变量。
--cpu-shares: 设置 CPU 使用权重。
--cpu-period: 限制 CPU CFS 周期。
--cpu-quota: 限制 CPU CFS 配额。
--cpuset-cpus: 指定可使用的 CPU ID。
--cpuset-mems: 指定可使用的内存节点 ID。
--disable-content-trust: 忽略内容信任验证（默认启用）。
-f: 指定 Dockerfile 的路径。
--force-rm: 强制在构建过程中删除中间容器。
--isolation: 使用指定的容器隔离技术。
--label=[]: 设置镜像的元数据。
-m: 设置内存的最大值。
--memory-swap: 设置交换空间的最大值（内存 + 交换空间），-1 表示不限制交换空间。
--no-cache: 构建镜像时不使用缓存。
--pull: 尝试拉取基础镜像的最新版本。
--quiet, -q: 安静模式，构建成功后只输出镜像 ID。
--rm: 构建成功后删除中间容器（默认启用）。
--shm-size: 设置 /dev/shm 的大小，默认值为 64M。
--ulimit: 设置 Ulimit 配置。
--squash: 将 Dockerfile 中所有步骤压缩为一层。
--tag, -t: 为镜像指定名称和标签，格式为 name:tag 或 name；可以在一次构建中为一个镜像设置多个标签。
--network: 在构建期间设置 RUN 指令的网络模式，默认值为 default。

1、构建镜像

docker build -t myimage:latest .

这会从当前目录读取 Dockerfile 并构建一个名为 myimage:latest 的镜像。

2、指定 Dockerfile 路径

docker build -f /path/to/Dockerfile -t myimage:latest .

这会从 /path/to/ 目录读取 Dockerfile 并构建一个名为 myimage:latest 的镜像。

3、设置构建参数

docker build --build-arg HTTP_PROXY=[http://proxy.example.com](http://proxy.example.com) -t myimage:latest .

这会在构建过程中使用 HTTP_PROXY 环境变量。

4、不使用缓存层构建镜像

docker build --no-cache -t myimage:latest .

这会在构建镜像时忽略所有缓存层，确保每一步都重新执行。

实例 - 使用 Dockerfile 构建镜像

1、创建 Dockerfile，内容如下：

# Dockerfile 示例
FROM ubuntu:20.04
LABEL maintainer="yourname@example.com"
RUN apt-get update && apt-get install -y nginx
COPY index.html /var/www/html/index.html
CMD ["nginx", "-g", "daemon off;"]

2、构建镜像

docker build -t mynginx:latest .

输出示例：

Sending build context to Docker daemon  3.072kB
Step 1/5 : FROM ubuntu:20.04
20.04: Pulling from library/ubuntu
...
Step 2/5 : LABEL maintainer="yourname@example.com"
...
Step 3/5 : RUN apt-get update && apt-get install -y nginx
...
Step 4/5 : COPY index.html /var/www/html/index.html
...
Step 5/5 : CMD ["nginx", "-g", "daemon off;"]
...
Successfully built 123456789abc
Successfully tagged mynginx:latest

3、验证镜像

docker images

输出示例：

注意事项

1 2	REPOSITORY TAG IMAGE ID CREATED SIZE mynginx latest 123456789abc 10 minutes ago 200MB

确保 Dockerfile 语法正确，并按照顺序执行每一步。
使用 .dockerignore 文件排除不需要的文件和目录，以减少构建上下文的大小。
在生产环境中，尽量使用精简的基础镜像以减小镜像体积和提高安全性。
避免在 Dockerfile 中暴露敏感信息（如密码、密钥）。

docker build 命令是构建 Docker 镜像的核心工具，通过定义清晰的 Dockerfile，可以自动化地构建应用程序的运行环境和依赖。在使用时，确保合理设置选项和优化 Dockerfile，以提高构建效率和镜像质量。

Docker history 命令

docker history 命令用于查看指定镜像的历史层信息，它显示了镜像创建过程中的每一层，包括创建时间、创建者、大小和注释等信息。

语法

docker history [OPTIONS] IMAGE

IMAGE: 要查看历史记录的镜像名称或 ID。

OPTIONS 说明：

-H, --human: 以人类可读的格式显示镜像大小（默认启用）。
--no-trunc: 显示完整的输出，不截断信息。
-q, --quiet: 仅显示镜像 ID。

实例

1、查看镜像历史

docker history myimage:latest

输出示例：

IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
sha256:123abc456def 2 days ago          /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon…   0B
sha256:789ghi012jkl 2 days ago          /bin/sh -c #(nop)  COPY file:abc123 in /var/…   1.5kB
sha256:345mno678pqr 2 days ago          /bin/sh -c apt-get update && apt-get install…   45.3MB
sha256:678stu901vwx 2 days ago          /bin/sh -c #(nop)  LABEL maintainer=yourname…   0B
sha256:901yza234bcd 2 days ago          /bin/sh -c #(nop)  FROM ubuntu:20.04           72.9MB

2、显示完整输出

docker history --no-trunc myimage:latest

3、仅显示镜像 ID

docker history -q myimage:latest

输出示例：

sha256:123abc456def
sha256:789ghi012jkl
sha256:345mno678pqr
sha256:678stu901vwx
sha256:901yza234bcd

操作实例

构建一个简单的镜像

1、创建一个 Dockerfile：

# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04

# 添加维护者信息
LABEL maintainer="yourname@example.com"

# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx

# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/

# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]

2、构建镜像：

docker build -t mynginx:latest .

3、查看镜像历史

docker history mynginx:latest

输出示例：

IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
sha256:123abc456def 1 minute ago        /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon…   0B
sha256:789ghi012jkl 1 minute ago        /bin/sh -c #(nop)  COPY file:abc123 in /var/…   1.5kB
sha256:345mno678pqr 1 minute ago        /bin/sh -c apt-get update && apt-get install…   45.3MB
sha256:678stu901vwx 1 minute ago        /bin/sh -c #(nop)  LABEL maintainer=yourname…   0B
sha256:901yza234bcd 1 minute ago        /bin/sh -c #(nop)  FROM ubuntu:20.04

注意事项

镜像历史信息包括每一层的创建指令和大小，有助于了解镜像的构建过程和内容。
使用 --no-trunc 选项可以查看完整的创建指令，避免信息截断。
在构建复杂镜像时，通过查看历史记录，可以帮助识别和优化 Dockerfile 中的冗余步骤。

docker history 命令是一个强大的工具，可以帮助开发者和运维人员了解镜像的构建历史和每一层的详细信息。通过查看镜像历史，可以更好地调试、优化和审计 Docker 镜像，确保镜像的高效和安全。

Docker save 命令

docker save 命令用于将一个或多个 Docker 镜像保存到一个 tar 归档文件中，以便在其他环境中分发或备份。

语法

docker save [OPTIONS] IMAGE [IMAGE...]

IMAGE: 要保存的一个或多个镜像名称或 ID。

OPTIONS 说明：

-o, --output: 指定输出文件的路径。

1、保存单个镜像到文件

docker save -o myimage.tar myimage:latest

这将 myimage:latest 镜像保存为 myimage.tar 文件。

2、保存多个镜像到同一个文件

docker save -o multiple_images.tar myimage:latest anotherimage:latest

这将 myimage:latest 和 anotherimage:latest 镜像保存到 multiple_images.tar 文件中。

实例

构建一个示例镜像

1、创建一个 Dockerfile：

# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04

# 添加维护者信息
LABEL maintainer="yourname@example.com"

# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx

# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/

# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]

构建镜像：

docker build -t mynginx:latest .

2、保存镜像到文件

docker save -o mynginx.tar mynginx:latest

这将 mynginx:latest 镜像保存为 mynginx.tar 文件。

3、验证保存的文件

ls -lh mynginx.tar

输出示例：

-rw-r--r-- 1 user user 200M Jul 24 14:00 mynginx.tar

4、加载保存的镜像

要将保存的镜像加载到另一个 Docker 环境中，可以使用 docker load 命令：

docker load -i mynginx.tar

注意事项

保存镜像时，会包含镜像的所有层，因此生成的 tar 文件可能会很大。
如果保存多个镜像到同一个文件中，使用 docker load 命令时会加载所有包含的镜像。
为了减少文件大小，可以在保存前使用 docker image prune 命令清理未使用的镜像和层。

docker save 命令是一个方便的工具，用于将 Docker 镜像保存为 tar 文件，以便于备份、分发和迁移。通过结合 docker load 命令，可以轻松地在不同环境中恢复和使用保存的镜像。

Docker load 命令

docker load 命令用于从由 docker save 命令生成的 tar 文件中加载 Docker 镜像。它可以将存档中的镜像和所有层加载到 Docker 中，使其可以在新环境中使用。

语法

docker load [OPTIONS]

OPTIONS 说明：

-i, --input: 指定输入文件的路径。
-q, --quiet: 安静模式，减少输出信息。

1、从文件加载镜像

docker load -i myimage.tar

这将从 myimage.tar 文件中加载镜像。

2、从标准输入加载镜像

cat myimage.tar | docker load

这将通过管道从标准输入加载镜像。

实例

1、构建和保存镜像

首先，构建一个示例镜像并保存，创建 Dockerfile：

# 使用 Ubuntu 作为基础镜像
FROM ubuntu:20.04

# 添加维护者信息
LABEL maintainer="yourname@example.com"

# 更新包列表并安装 Nginx
RUN apt-get update && apt-get install -y nginx

# 复制自定义网页到 Nginx 的默认网页目录
COPY index.html /var/www/html/

# 设置启动时的默认命令
CMD ["nginx", "-g", "daemon off;"]

构建镜像：

docker build -t mynginx:latest .

保存镜像到文件：

docker save -o mynginx.tar mynginx:latest

2、加载镜像

从文件加载镜像：

docker load -i mynginx.tar

3、验证加载的镜像

docker images

输出示例：

1 2	REPOSITORY TAG IMAGE ID CREATED SIZE mynginx latest 123abc456def 1 minute ago 200MB

注意事项

加载的镜像包括其所有层和元数据，与保存时的状态完全一致。
使用 docker load 时，所有包含在 tar 文件中的镜像都会被加载。
加载过程中可能需要较长时间，具体取决于镜像的大小和系统性能。

docker load 命令是从保存的 tar 文件中恢复 Docker 镜像的便捷方法。通过结合 docker save 和 docker load，用户可以轻松地在不同环境中备份、分发和迁移 Docker 镜像。

Docker import 命令

docker import 命令用于从一个 tar 文件或 URL 导入容器快照，从而创建一个新的 Docker 镜像。

与 docker load 不同，docker import 可以从容器快照中创建新的镜像，而不需要保留镜像的历史和元数据。

语法

docker import [OPTIONS] file|URL|- [REPOSITORY[:TAG]]

file|URL|-: 输入文件的路径、本地文件或 URL，或者使用 - 从标准输入读取。
[REPOSITORY[:TAG]]: （可选）为导入的镜像指定仓库和标签。

OPTIONS 说明：

-c, --change: 在导入过程中应用 Dockerfile 指令，如 CMD、ENTRYPOINT、ENV 等。
-m, --message: 为导入的镜像添加注释。

1、从本地 tar 文件导入镜像

docker import mycontainer.tar mynewimage:latest

这将从 mycontainer.tar 文件导入镜像，并命名为 mynewimage:latest。

2、从 URL 导入镜像

docker import [http://example.com/mycontainer.tar](http://example.com/mycontainer.tar) mynewimage:latest

这将从指定的 URL 导入镜像，并命名为 mynewimage:latest。

3、从标准输入导入镜像

cat mycontainer.tar | docker import - mynewimage:latest

这将通过管道从标准输入读取 tar 文件并导入镜像。

4、在导入过程中应用变更

docker import -c "ENV LANG=en_US.UTF-8" -c "CMD /bin/bash" mycontainer.tar mynewimage:latest

这将从 mycontainer.tar 导入镜像，并在过程中设置环境变量 LANG 和命令 CMD。

实例

1、导出容器快照

首先，创建并运行一个容器：

docker run -d --name mycontainer ubuntu:20.04 sleep 3600

导出容器快照：

docker export mycontainer -o mycontainer.tar

2、导入容器快照

从 tar 文件导入镜像：

docker import mycontainer.tar mynewimage:latest

3、验证导入的镜像

docker images

输出示例：

1 2	REPOSITORY TAG IMAGE ID CREATED SIZE mynewimage latest 123abc456def 1 minute ago 72.9MB

4、运行导入的镜像

docker run -it mynewimage:latest /bin/bash

注意事项

docker import 创建的镜像不会保留原始镜像的历史和元数据。
使用 -c 选项可以在导入过程中应用 Dockerfile 指令，从而自定义新镜像的配置。
导入的 tar 文件必须是使用 docker export 创建的容器快照，或者是兼容的其他格式。

docker import 命令是一种从容器快照创建新镜像的灵活方法，适用于迁移、恢复和自定义 Docker 镜像的场景。通过使用 docker import，用户可以轻松地从容器快照生成新的镜像，并在导入过程中应用额外的配置。

Docker命令-镜像仓库

2025-02-25T02:10:10.000Z

Docker login/logout 命令

docker login 和 docker logout 命令用于管理 Docker 客户端与 Docker 注册表的身份验证。通过 docker login 命令，用户可以登录到 Docker 注册表，访问和推送镜像；通过 docker logout 命令，用户可以退出登录。

docker login : 登陆到一个Docker 镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub
docker logout : 登出一个D ocker 镜像仓库，如果未指定镜像仓库地址，默认为官方仓库 Docker Hub

docker login 命令用于登录到 Docker 注册表。

默认情况下，它登录到 Docker Hub，但也可以登录到其他 Docker 注册表。

语法

docker login [OPTIONS] [SERVER]

SERVER: Docker 注册表的服务器地址（默认是 Docker Hub）。
-u, --username: 登录用户名。
-p, --password: 登录密码（不推荐在命令行使用）。
--password-stdin: 从标准输入读取密码。

使用示例

1、登录到 Docker Hub

docker login

提示输入 Docker Hub 用户名和密码。

2、登录到 Docker Hub（指定用户名）

docker login --username myusername

3、提示输入 Docker Hub 密码。

从标准输入读取密码：

echo "mypassword" | docker login --username myusername --password-stdin

从标准输入读取密码，避免在命令行明文输入密码。

4、登录到自定义注册表

docker login myregistry.com

提示输入自定义注册表的用户名和密码。

docker logout

docker logout 命令用于退出当前登录的 Docker 注册表。默认情况下，它退出 Docker Hub，但也可以指定其他注册表。

语法

docker logout [SERVER]

SERVER: Docker 注册表的服务器地址（默认是 Docker Hub）。

使用示例

1、退出 Docker Hub

docker logout

退出当前用户在 Docker Hub 的登录状态。

2、退出自定义注册表

docker logout myregistry.com

退出当前用户在 myregistry.com 的登录状态。

操作实例

1、登录 Docker Hub

docker login

输出：

1
2
3

Username: myusername
Password: 
Login Succeeded

2、从标准输入读取密码登录 Docker Hub

echo "mypassword" | docker login --username myusername --password-stdin

输出：

3、登录自定义注册表

docker login myregistry.com

输出：

1
2
3

Username: myusername
Password: 
Login Succeeded

4、退出 Docker Hub

docker logout

输出：

Removing login credentials for [https://index.docker.io/v1/](https://index.docker.io/v1/)

5、退出自定义注册表

docker logout myregistry.com

输出：

Removing login credentials for myregistry.com

注意事项

不推荐在命令行直接使用 -p 选项输入密码，因为这样密码会以明文形式暴露在命令历史记录中。
使用 --password-stdin 可以避免密码明文暴露，增强安全性。
确保在公共或共享环境中执行 docker logout，以防止其他用户访问您的账户。

Docker pull 命令

docker pull 命令用于从 Docker 注册表（例如 Docker Hub）中拉取（下载）镜像到本地。

docker pull 命令允许用户获取所需的镜像以便在本地运行容器。

语法

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

NAME: 镜像名称，通常包含注册表地址（如 docker.io/library/ubuntu）。
TAG（可选）: 镜像标签，默认为 latest。
DIGEST（可选）: 镜像的 SHA256 摘要。

常用选项：

--all-tags, -a: 下载指定镜像的所有标签。
--disable-content-trust: 跳过镜像签名验证。

1、拉取默认标签（latest）的镜像

docker pull ubuntu

这会从 Docker Hub 拉取名为 ubuntu 的镜像，标签默认为 latest。

2、拉取特定标签的镜像

docker pull ubuntu:20.04

这会从 Docker Hub 拉取名为 ubuntu 的镜像，标签为 20.04。

3、拉取特定摘要的镜像

docker pull ubuntu@sha256:12345abcdef...

这会拉取具有特定 SHA256 摘要的 ubuntu 镜像。

4、拉取所有标签的镜像

docker pull --all-tags ubuntu

这会拉取 ubuntu 镜像的所有可用标签。

5、从自定义注册表拉取镜像

docker pull myregistry.com/myrepo/myimage:mytag

这会从 myregistry.com 注册表中拉取 myrepo 仓库中的 myimage 镜像，标签为 mytag。

实例

1、拉取 Ubuntu 镜像：

docker pull ubuntu

输出示例：

Using default tag: latest
latest: Pulling from library/ubuntu
Digest: sha256:12345abcdef...
Status: Downloaded newer image for ubuntu:latest
docker.io/library/ubuntu:latest

2、拉取指定标签的 Ubuntu 镜像

docker pull ubuntu:20.04

输出示例：

20.04: Pulling from library/ubuntu
Digest: sha256:67890abcdef...
Status: Downloaded newer image for ubuntu:20.04
docker.io/library/ubuntu:20.04

注意事项

默认标签为 latest，但最好显式指定标签以避免拉取意外的版本。
确保有足够的磁盘空间来存储拉取的镜像。
在生产环境中，建议使用镜像的摘要（digest）以确保镜像的唯一性和一致性。

docker pull 命令是获取 Docker 镜像的基本工具，通过指定镜像名称、标签或摘要，可以从 Docker 注册表中下载所需的镜像。

Docker push 命令

docker push 命令用于将本地构建的 Docker 镜像推送（上传）到 Docker 注册表（如 Docker Hub 或私有注册表）。这使得镜像可以在其他系统或环境中共享和使用。

语法

docker push [OPTIONS] NAME[:TAG]

NAME: 镜像名称，通常包含注册表地址（如 docker.io/myrepo/myimage）。
TAG（可选）: 镜像标签，默认为 latest。

OPTIONS 说明：

–disable-content-trust :忽略镜像的校验,默认开启

1、推送默认标签（latest）的镜像

docker push myrepo/myimage

这会将本地的 myrepo/myimage:latest 镜像推送到 Docker Hub。

2、推送特定标签的镜像

docker push myrepo/myimage:1.0

这会将本地的 myrepo/myimage:1.0 镜像推送到 Docker Hub。

3、推送到自定义注册表

docker push myregistry.com/myrepo/myimage:mytag

这会将本地的 myrepo/myimage:mytag 镜像推送到 myregistry.com 注册表。

实例

推送镜像到 Docker Hub

1、登录到 Docker Hub

docker login

2、构建一个镜像

docker build -t myrepo/myimage:1.0 .

3、推送镜像到 Docker Hub

docker push myrepo/myimage:1.0

输出示例：

1
2
3

The push refers to repository [docker.io/myrepo/myimage]
d1e017099d17: Pushed
1.0: digest: sha256:12345abcdef... size: 1234

推送镜像到自定义注册表

1、登录到自定义注册表

docker login myregistry.com

2、构建一个镜像

docker build -t myregistry.com/myrepo/myimage:mytag .

3、推送镜像到自定义注册表

docker push myregistry.com/myrepo/myimage:mytag

输出示例：

1
2
3

The push refers to repository [myregistry.com/myrepo/myimage]
d1e017099d17: Pushed
mytag: digest: sha256:67890abcdef... size: 5678

注意事项

确保已登录到目标注册表（使用 docker login 命令）。
在推送镜像之前，确保镜像标签正确，并符合注册表的命名规范。
推送操作需要网络连接，镜像大小和网络速度会影响推送时间。
对于私有注册表，确保拥有相应的访问权限和配置信息。

docker push 命令是将本地 Docker 镜像推送到注册表的关键工具，通过使用这个命令，用户可以方便地共享、部署和管理 Docker 镜像。在使用时，确保正确登录和标签设置，以保证镜像能够正确推送到目标注册表。

Docker search 命令

docker search 命令用于在 Docker Hub 或其他注册表中搜索镜像。

docker search 命令帮助用户查找和获取所需的镜像，并提供了对搜索结果进行过滤和排序的功能。

语法

docker search [OPTIONS] TERM

TERM: 要搜索的关键字。

常用选项：

–automated :只列出 automated build类型的镜像；
–no-trunc :显示完整的镜像描述；
-f <过滤条件>:列出收藏数不小于指定值的镜像。

1、搜索镜像

docker search ubuntu

这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像。

2、限制返回的搜索结果数量

docker search --limit 5 ubuntu

这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并只返回前 5 个结果。

3、过滤搜索结果

docker search --filter stars=50 ubuntu

这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并只返回 stars 数不低于 50 的镜像。

4、不截断输出

docker search --no-trunc ubuntu

这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并显示完整的镜像描述。

5、自定义格式输出

docker search --format "{{.Name}}: {{.StarCount}} stars" ubuntu

这会在 Docker Hub 中搜索包含关键字 ubuntu 的镜像，并以指定格式显示镜像名称和 star 数。

实例

1、搜索 Ubuntu 镜像

docker search ubuntu输出示例：

NAME                             DESCRIPTION                                     STARS   OFFICIAL  AUTOMATED
ubuntu                           Ubuntu is a Debian-based Linux operating sys…   10000   [OK]
dorowu/ubuntu-desktop-lxde-vnc   Ubuntu with openssh-server and NoVNC            4000               [OK]
rastasheep/ubuntu-sshd           Dockerized SSH service, built on top of offi…   2000               [OK]

参数说明：

NAME: 镜像仓库源的名称

DESCRIPTION: 镜像的描述

OFFICIAL: 是否 docker 官方发布

stars: 类似 Github 里面的 star，表示点赞、喜欢的意思。

AUTOMATED: 自动构建。

2、限制返回结果数量

docker search --limit 3 ubuntu输出示例：

NAME                              DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
ubuntu                            Ubuntu is a Debian-based Linux operating sys…   10000     [OK]
dorowu/ubuntu-desktop-lxde-vnc    Ubuntu with openssh-server and NoVNC            4000                 [OK]
rastasheep/ubuntu-sshd            Dockerized SSH service, built on top of offi…   2000                 [OK]

3、过滤搜索结果

docker search --filter stars=1000 ubuntu

输出示例：

NAME                            DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
ubuntu                          Ubuntu is a Debian-based Linux operating sys…   10000     [OK]
dorowu/ubuntu-desktop-lxde-vnc  Ubuntu with openssh-server and NoVNC            4000                 [OK]
rastasheep/ubuntu-sshd          Dockerized SSH service, built on top of offi…   2000                 [OK]

4、自定义格式输出

docker search --format "{{.Name}}: {{.StarCount}} stars" ubuntu

输出示例：

1
2
3

ubuntu: 10000 stars
dorowu/ubuntu-desktop-lxde-vnc: 4000 stars
rastasheep/ubuntu-sshd: 2000 stars

注意事项

搜索结果可能包含大量镜像，可以使用过滤和排序选项来精简结果。
确保使用准确的关键字以获取相关结果。
docker search 默认搜索 Docker Hub，若需要搜索其他注册表，需相应配置 Docker 客户端。

docker search 命令是查找 Docker 镜像的重要工具，通过指定关键字和选项，用户可以高效地在 Docker 注册表中搜索和获取所需的镜像。这个命令适用于各种场景，包括查找特定功能的镜像、获取高评分镜像以及自定义结果显示。

Docker命令-容器的root文件系统（rootfs）命令

2025-02-10T02:10:10.000Z

Docker commit 命令

docker commit 命令用于将容器的当前状态保存为一个新的 Docker 镜像。

docker commit 命令通常用于创建镜像来保存容器的状态，以便在将来可以重用或分发该镜像。

语法

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

OPTIONS说明：

-a :提交的镜像作者。
-c :使用 Dockerfile 指令来创建镜像。
-m :提交时的说明文字。
-p :提交镜像前暂停容器（默认为 true）。

将容器保存为新镜像:

docker commit my_container my_new_image

将名为 my_container 的容器保存为一个名为 my_new_image 的新镜像。

指定标签:

docker commit my_container my_new_image:latest

将容器保存为带有 latest 标签的镜像。

添加作者信息和提交信息:

docker commit -a “John Doe” -m “Added new features” my_container my_new_image

将容器保存为新镜像，并添加作者信息和提交信息。

在不暂停容器的情况下提交镜像:

docker commit --pause=false my_container my_new_image

在不暂停容器的情况下，将其保存为新镜像。

实例

启动一个容器:

docker run -d -it --name my_container ubuntu bash

进行一些更改:

1 2	docker exec my_container apt-get update docker exec my_container apt-get install -y nginx

提交容器为新镜像:

docker commit -a “Your Name” -m “Installed nginx” my_container my_new_image

查看新镜像:

docker images

常用场景

保存工作进度: 在开发或测试过程中，将容器的当前状态保存为镜像，以便稍后可以恢复。
创建基础镜像: 为特定应用程序或环境配置创建自定义基础镜像。
分发配置: 将特定配置或应用程序状态保存为镜像，以便分发给其他团队成员或在不同环境中使用。

docker commit 命令是一个强大的工具，允许用户将容器的当前状态保存为新的 Docker 镜像。通过使用该命令，用户可以创建自定义镜像，以便在将来重用或分发。添加适当的作者和提交信息，有助于跟踪镜像的历史和变化。

Docker cp 命令

docker cp 命令用于在 Docker 容器和宿主机之间复制文件或目录。

docker cp 命令支持从容器到宿主机，或从宿主机到容器的文件复制操作。

语法

1 2	docker cp [OPTIONS] SRC_PATH CONTAINER:DEST_PATH docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH

SRC_PATH: 源路径（可以是容器内的路径或宿主机的路径）。
CONTAINER: 容器的名称或 ID。
DEST_PATH: 目标路径（可以是容器内的路径或宿主机的路径）。

从容器复制文件到宿主机

docker cp my_container:/path/in/container /path/on/host

将容器 my_container 内的 /path/in/container 文件或目录复制到宿主机的 /path/on/host。

从宿主机复制文件到容器

docker cp /path/on/host my_container:/path/in/container

将宿主机上的 /path/on/host 文件或目录复制到容器 my_container 内的 /path/in/container。

从容器复制目录到宿主机

docker cp my_container:/path/in/container /path/on/host

将容器内的 /path/in/container 目录及其内容复制到宿主机的 /path/on/host。

从宿主机复制目录到容器

docker cp /path/on/host my_container:/path/in/container

将宿主机上的 /path/on/host 目录及其内容复制到容器 my_container 内的 /path/in/container。

实例

容器复制文件到宿主机

启动一个容器并创建一个文件:

docker run -d --name my_container ubuntu bash -c “echo ‘Hello, Docker!’ > /hello.txt”

从容器复制文件到宿主机:

docker cp my_container:/hello.txt ./hello.txt

将容器内的 /hello.txt 文件复制到当前宿主机目录下。

查看复制的文件内容:

cat hello.txt

输出：

Hello, Docker!

从宿主机复制文件到容器

复制一个文件到容器:

docker cp ./hello.txt my_container:/hello.txt

将宿主机上的 hello.txt 文件复制到容器内的 /hello.txt。

进入容器查看文件内容:

docker exec -it my_container cat /hello.txt

输出：

Hello, Docker!

注意事项

docker cp 命令不会修改源文件或目录，它仅进行复制操作。
目标路径必须是有效的路径，且宿主机或容器中应有足够的权限进行写入操作。
在处理大文件或大目录时，复制操作可能需要一些时间。

docker cp 命令是 Docker 提供的一个有用工具，用于在容器和宿主机之间复制文件或目录。这个命令适用于备份、配置更新、日志收集等操作，帮助用户方便地管理和操作容器中的文件。

Docker diff 命令

docker diff 命令用于显示 Docker 容器文件系统的变更。它显示自容器创建以来，文件系统中发生的所有修改，包括添加、删除和修改的文件或目录。

docker diff 命令对于调试和理解容器的文件系统变化非常有用。

语法

docker diff CONTAINER

CONTAINER: 容器的名称或 ID。

docker diff 命令的输出包含以下三种类型的变更：

查看容器的文件系统变更

docker diff my_container

显示名为 my_container 的容器的文件系统变更。

实例

启动一个容器并修改文件系统:

docker run -d --name my_container ubuntu bash -c “echo ‘Hello, Docker!’ > /hello.txt && sleep 3600”

查看容器的文件系统变更:

docker diff my_container

输出示例：

A /hello.txt

此输出表示 /hello.txt 文件在容器文件系统中被新增了。

删除容器中的文件:

docker exec my_container rm /hello.txt

再次查看容器的文件系统变更:

docker diff my_container

输出示例：

D /hello.txt

此输出表示 /hello.txt 文件在容器文件系统中被删除了。

注意事项

docker diff 命令仅显示容器的文件系统变化，不显示容器内的其他状态信息（如运行的进程）。
输出信息可能会因容器内文件系统的变化而不断变化，因此应在需要时及时查看。

docker diff 命令是一个强大的工具，用于显示 Docker 容器文件系统的变化。通过使用该命令，用户可以轻松查看和了解容器自创建以来所做的文件系统更改，有助于调试、审计和分析容器的行为。

Docker命令-容器操作

2025-01-28T04:12:13.000Z

Docker ps 命令

docker ps 命令用于列出 Docker 容器。

默认情况下，docker ps 命令只显示运行中的容器，但也可以通过指定选项来显示所有容器，包括停止的容器。

语法

docker ps [OPTIONS]

OPTIONS说明：

-a, --all: 显示所有容器，包括停止的容器。
-q, --quiet: 只显示容器 ID。
-l, --latest: 显示最近创建的一个容器，包括所有状态。
-n: 显示最近创建的 n 个容器，包括所有状态。
--no-trunc: 不截断输出。
-s, --size: 显示容器的大小。
--filter, -f: 根据条件过滤显示的容器。
--format: 格式化输出。

实例

1、列出所有在运行的容器信息

默认情况下，docker ps 只显示正在运行的容器。

docker ps
CONTAINER ID   IMAGE          COMMAND                ...  PORTS                    NAMES
09b93464c2f7   nginx:latest   "nginx -g 'daemon off" ...  80/tcp, 443/tcp          myrunoob
96f7f14e99ab   mysql:5.6      "docker-entrypoint.sh" ...  0.0.0.0:3306->3306/tcp   mymysql

输出详情介绍：

CONTAINER ID: 容器 ID。

IMAGE: 使用的镜像。

COMMAND: 启动容器时运行的命令。

CREATED: 容器的创建时间。

STATUS: 容器状态。

状态有7种：

created（已创建）
restarting（重启中）
running（运行中）
removing（迁移中）
paused（暂停）
exited（停止）
dead（死亡）

PORTS: 容器的端口信息和使用的连接类型（tcp\udp）。

NAMES: 自动分配的容器名称。

2、列出所有容器，包括停止的容器

docker ps -a

显示所有容器，包括停止的容器。

3、只显示容器 ID

docker ps -q

只显示容器 ID。

4、显示最近创建的一个容器

docker ps -l

显示最近创建的一个容器，包括所有状态。

5、显示最近创建的 n 个容器

docker ps -n 3

显示最近创建的 3 个容器，包括所有状态。

6、显示容器的大小

docker ps -s

显示容器的大小。

7、根据条件过滤显示的容器

docker ps -f "status=exited"

显示状态为 exited 的容器。

docker ps -f "name=my_container"

显示名称包含 my_container 的容器。

8、格式化输出

docker ps --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"

以表格形式显示容器的 ID、名称和状态。

常见过滤器

status: 容器状态（如 running、paused、exited）。
name: 容器名称。
id: 容器 ID。
label: 容器标签。
ancestor: 容器镜像。

使用场景

监控容器状态: 实时监控运行中的容器状态和资源使用情况。
调试和管理: 查看所有容器，包括停止的容器，以便进行调试和管理操作。
自动化脚本: 使用过滤器和格式化选项，便于在自动化脚本中获取特定容器信息。

docker inspect 命令

docker inspect 命令用于获取 Docker 对象（容器、镜像、卷、网络等）的详细信息。

docker inspect 命令返回 JSON 格式的详细信息，可以帮助用户了解对象的配置和状态。

语法

docker inspect [OPTIONS] NAME|ID [NAME|ID...]

OPTIONS 说明：

-f, --format: 使用 Go 模板语法格式化输出。
--type: 返回指定类型的对象信息（可选类型：container、image、network、volume）。

实例

1、检查容器

docker inspect my_container

返回 my_container 容器的详细信息。

2、检查镜像

docker inspect my_image

返回 my_image 镜像的详细信息。

3、检查卷

docker inspect my_volume

返回 my_volume 卷的详细信息。

4、检查网络

docker inspect my_network

返回 my_network 网络的详细信息。

5、格式化输出

docker inspect --format '{{ .State.Running }}' my_container

返回 my_container 容器的运行状态，格式化输出为布尔值。

6、检查多个对象

docker inspect my_container my_image

返回 my_container 容器和 my_image 镜像的详细信息。

实例输出

容器信息：

docker inspect my_container

输出：

[
    {
        "Id": "d2f5e3f19a6a",
        "Created": "2024-07-23T00:00:00Z",
        "Path": "bash",
        "Args": [],
        "State": {
            "Status": "running",
            "Running": true,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 12345,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2024-07-23T00:00:00Z",
            "FinishedAt": "0001-01-01T00:00:00Z"
        },
        "Image": "sha256:abc123",
        "ResolvConfPath": "/var/lib/docker/containers/d2f5e3f19a6a/resolv.conf",
        "HostnamePath": "/var/lib/docker/containers/d2f5e3f19a6a/hostname",
        "HostsPath": "/var/lib/docker/containers/d2f5e3f19a6a/hosts",
        "LogPath": "/var/lib/docker/containers/d2f5e3f19a6a/d2f5e3f19a6a-json.log",
        "Name": "/my_container",
        "RestartCount": 0,
        "Driver": "overlay2",
        "Platform": "linux",
        "MountLabel": "",
        "ProcessLabel": "",
        "AppArmorProfile": "",
        "ExecIDs": null,
        "HostConfig": {
            "Binds": null,
            "ContainerIDFile": "",
            "LogConfig": {
                "Type": "json-file",
                "Config": {}
            },
            "NetworkMode": "default",
            "PortBindings": {},
            "RestartPolicy": {
                "Name": "no",
                "MaximumRetryCount": 0
            },
            "AutoRemove": false,
            "VolumeDriver": "",
            "VolumesFrom": null,
            "CapAdd": null,
            "CapDrop": null,
            "Dns": [],
            "DnsOptions": [],
            "DnsSearch": [],
            "ExtraHosts": null,
            "GroupAdd": null,
            "IpcMode": "private",
            "Cgroup": "",
            "Links": null,
            "OomScoreAdj": 0,
            "PidMode": "",
            "Privileged": false,
            "PublishAllPorts": false,
            "ReadonlyRootfs": false,
            "SecurityOpt": null,
            "UTSMode": "",
            "UsernsMode": "",
            "ShmSize": 67108864,
            "Runtime": "runc",
            "ConsoleSize": [
                0,
                0
            ],
            "Isolation": "",
            "CpuShares": 0,
            "Memory": 0,
            "NanoCpus": 0,
            "CgroupParent": "",
            "BlkioWeight": 0,
            "BlkioWeightDevice": null,
            "BlkioDeviceReadBps": null,
            "BlkioDeviceWriteBps": null,
            "BlkioDeviceReadIOps": null,
            "BlkioDeviceWriteIOps": null,
            "CpuPeriod": 0,
            "CpuQuota": 0,
            "CpuRealtimePeriod": 0,
            "CpuRealtimeRuntime": 0,
            "CpusetCpus": "",
            "CpusetMems": "",
            "Devices": null,
            "DiskQuota": 0,
            "KernelMemory": 0,
            "MemoryReservation": 0,
            "MemorySwap": 0,
            "MemorySwappiness": null,
            "OomKillDisable": false,
            "PidsLimit": null,
            "Ulimits": null,
            "CpuCount": 0,
            "CpuPercent": 0,
            "IOMaximumIOps": 0,
            "IOMaximumBandwidth": 0,
            "Mounts": [],
            "MaskedPaths": [
                "/proc/asound",
                "/proc/acpi",
                "/proc/kcore",
                "/proc/keys",
                "/proc/latency_stats",
                "/proc/timer_list",
                "/proc/timer_stats",
                "/proc/sched_debug",
                "/proc/scsi",
                "/sys/firmware"
            ],
            "ReadonlyPaths": [
                "/proc/bus",
                "/proc/fs",
                "/proc/irq",
                "/proc/sys",
                "/proc/sysrq-trigger"
            ]
        },
        "GraphDriver": {
            "Data": {
                "LowerDir": "/var/lib/docker/overlay2/l/abc123/diff",
                "MergedDir": "/var/lib/docker/overlay2/merged",
                "UpperDir": "/var/lib/docker/overlay2/upper",
                "WorkDir": "/var/lib/docker/overlay2/work"
            },
            "Name": "overlay2"
        },
        "Mounts": [],
        "Config": {
            "Hostname": "d2f5e3f19a6a",
            "Domainname": "",
            "User": "",
            "AttachStdin": false,
            "AttachStdout": false,
            "AttachStderr": false,
            "ExposedPorts": {},
            "Tty": false,
            "OpenStdin": false,
            "StdinOnce": false,
            "Env": [
                "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Cmd": [
                "bash"
            ],
            "Image": "ubuntu",
            "Volumes": null,
            "WorkingDir": "",
            "Entrypoint": null,
            "OnBuild": null,
            "Labels": {}
        },
        "NetworkSettings": {
            "Bridge": "",
            "SandboxID": "abc123",
            "HairpinMode": false,
            "LinkLocalIPv6Address": "",
            "LinkLocalIPv6PrefixLen": 0,
            "Ports": {},
            "SandboxKey": "/var/run/docker/netns/abc123",
            "SecondaryIPAddresses": null,
            "SecondaryIPv6Addresses": null,
            "EndpointID": "abc123",
            "Gateway": "172.17.0.1",
            "GlobalIPv6Address": "",
            "GlobalIPv6PrefixLen": 0,
            "IPAddress": "172.17.0.2",
            "IPPrefixLen": 16,
            "IPv6Gateway": "",
            "MacAddress": "02:42:ac:11:00:02",
            "Networks": {
                "bridge": {
                    "IPAMConfig": null,
                    "Links": null,
                    "Aliases": null,
                    "NetworkID": "abc123",
                    "EndpointID": "abc123",
                    "Gateway": "172.17.0.1",
                    "IPAddress": "172.17.0.2",
                    "IPPrefixLen": 16,
                    "IPv6Gateway": "",
                    "GlobalIPv6Address": "",
                    "GlobalIPv6PrefixLen": 0,
                    "MacAddress": "02:42:ac:11:00:02",
                    "DriverOpts": null
                }
            }
        }
    }
]

使用场景

调试容器: 获取容器的详细配置信息，以便进行调试和排查问题。
查看网络配置: 查看容器的网络配置信息，了解其网络连接状态。
监控资源: 获取容器的资源配置信息和使用情况，便于进行资源管理和监控。
脚本自动化: 在自动化脚本中使用 docker inspect 获取对象的详细信息，以进行后续操作。

docker inspect 命令是 Docker 中非常强大和实用的命令之一，允许用户获取容器、镜像、卷、网络等对象的详细信息。通过使用该命令，用户可以深入了解和管理 Docker 对象的配置和状态，满足各种调试、监控和管理需求。

Docker top 命令

docker top 命令用于显示指定容器中的正在运行的进程。

docker top 命令类似于 Linux 中的 top 或 ps 命令，它帮助用户查看容器内的进程信息，便于监控和调试容器内的活动。

语法

docker top [OPTIONS] CONTAINER [ps OPTIONS]

查看容器内的进程:

docker top my_container

这将显示容器 my_container 中所有正在运行的进程。

使用自定义 ps 选项:

docker top my_container -o pid,comm

这将显示容器 my_container 中所有正在运行的进程，并只显示 pid 和 comm 列。

实例

查看容器内的进程：

docker top my_container

示例输出：

1
2
3

UID       PID        PPID      C      STIME    TTY        TIME          CMD
root      1725       1708      0      14:02    ?          00:00:00      bash
root      1767       1725      0      14:03    ?          00:00:00      ps

自定义输出：

docker top my_container -o pid,comm

示例输出：

1
2
3

PID                 COMMAND
1725                bash
1767                ps

常用场景

监控容器内部活动: 通过查看容器内的进程，用户可以监控容器内部正在运行的应用程序和服务。
调试和排查问题: 当容器出现问题时，可以通过 docker top 命令查看容器内的进程，帮助排查问题。
资源管理: 了解容器内的进程和资源使用情况，便于进行资源管理和优化。

docker top 命令是一个有用的工具，帮助用户查看容器内正在运行的进程信息。通过该命令，用户可以监控、调试和管理容器内的活动，确保容器正常运行。

Docker attach 命令

docker attach 命令用于附加到正在运行的 Docker 容器的标准输入、输出和错误输出（stdin、stdout、stderr）。允许用户直接与容器交互，就像与正在运行的进程交互一样。

语法

docker attach [OPTIONS] CONTAINER

常用选项

--detach-keys: 设置一个在容器中分离的键序列（例如，ctrl-c）。
--no-stdin: 不附加标准输入。
--sig-proxy: 当键盘中断时，将信号代理到容器（默认为 true）。

实例

附加到正在运行的容器：

docker attach my_container

附加到名为 my_container 的容器，用户可以直接与容器的标准输入、输出和错误输出交互。

附加到容器并禁用标准输入：

docker attach --no-stdin my_container

附加到 my_container 容器，但不附加标准输入。

设置分离键序列：

docker attach --detach-keys="ctrl-c" my_container

附加到 my_container 容器，并设置 ctrl-c 为分离键序列。

注意事项

如果附加到一个已经附加了其他会话的容器，所有会话将共享相同的标准输入、输出和错误输出。这意味着多个会话中的输出可能会混杂在一起。
使用 docker attach 进行交互时，需要注意正确设置分离键序列，以确保能够安全地分离而不停止容器。

常用场景

调试和故障排除: 直接附加到正在运行的容器进行调试和故障排除。
监控: 实时查看容器内的输出和日志。
交互操作: 需要与容器内的应用程序进行交互时使用。

docker attach 命令是 Docker 中一个有用的命令，允许用户附加到正在运行的容器并与其交互。通过此命令，用户可以实时查看容器的输出，进行调试和故障排除，以及执行其他交互操作。使用适当的选项和分离键序列，可以灵活地管理和控制与容器的交互。

Docker events 命令

docker events 命令用于实时获取 Docker 守护进程生成的事件。

docker events 命令允许用户监控 Docker 容器、镜像、网络和卷的各种操作事件，例如创建、启动、停止、删除等。

语法

docker events [OPTIONS]

OPTIONS说明：

-f, --filter: 根据提供的条件过滤输出。
--format: 使用 Go 模板格式化输出。
--since: 显示从指定时间开始的事件。
--until: 显示直到指定时间的事件。

实例

获取所有事件：

docker events

输出：

2023-07-22T15:04:05.123456789Z container create 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:06.123456789Z container start 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:10.123456789Z container stop 123abc456def (image=ubuntu, name=my_container)
2023-07-22T15:04:11.123456789Z container destroy 123abc456def (image=ubuntu, name=my_container)

过滤事件：

docker events --filter event=stop

以上命令只显示容器停止事件。

输出：

2023-07-22T15:04:10.123456789Z container stop 123abc456def (image=ubuntu, name=my_container)

格式化输出：

docker events --format '{{.Time}} - {{.Type}} - {{.Action}}'

以上命令使用指定格式显示事件。

输出：

2023-07-22T15:04:05.123456789Z - container - create
2023-07-22T15:04:06.123456789Z - container - start
2023-07-22T15:04:10.123456789Z - container - stop
2023-07-22T15:04:11.123456789Z - container - destroy

显示从指定时间开始的事件：

docker events --since "2023-07-22T15:04:05"

以上命令显示从 2023-07-22T15:04:05 开始的事件。

显示直到指定时间的事件：

docker events --until "2023-07-22T16:04:05"

以上命令显示直到 2023-07-22T16:04:05 的事件。

Docker logs 命令

docker logs 命令用于获取和查看容器的日志输出。

docker logs 命令非常有用，可以帮助用户调试和监控运行中的容器。

语法

docker logs [OPTIONS] CONTAINER

常用选项：

-f, --follow: 跟随日志输出（类似于 tail -f）。
--since: 从指定时间开始显示日志。
-t, --timestamps: 显示日志时间戳。
--tail: 仅显示日志的最后部分，例如 --tail 10 显示最后 10 行。
--details: 显示提供给日志的额外详细信息。
--until: 显示直到指定时间的日志。

实例

显示容器日志

docker logs my_container

显示名为 my_container 的容器的所有日志，输出内容：

hello world
hello world
hello world
...

跟随日志输出

docker logs -f my_container

持续显示 my_container 的日志输出，输出内容：

hello world
hello world
hello world
...

显示带时间戳的日志

docker logs -t my_container

显示包含时间戳的日志，输出内容：

2023-07-22T15:04:05.123456789Z hello world
2023-07-22T15:04:06.123456789Z hello world
2023-07-22T15:04:07.123456789Z hello world
...

从指定时间开始显示日志

1	docker logs --since="2023-07-22T15:00:00" my_container

显示 2023-07-22T15:00:00 之后的日志。

显示最后 10 行日志

docker logs --tail 10 my_container

显示 my_container 的最后 10 行日志。

显示额外详细信息的日志

docker logs --details my_container

显示 my_container 的日志，并包含额外详细信息。

显示直到指定时间的日志

docker logs --until=“2023-07-22T16:00:00” my_container

显示 2023-07-22T16:00:00 之前的日志。

Docker wait 命令

docker wait 命令用于阻塞，直到指定的容器停止运行，然后返回容器的退出代码。

docker wait 命令对于自动化脚本非常有用，因为它可以等待容器完成某项任务，并根据容器的退出状态采取后续操作。

语法

docker wait [OPTIONS] CONTAINER [CONTAINER...]

等待一个容器停止并获取其退出代码:

docker wait my_container

等待多个容器停止并获取它们的退出代码:

docker wait container1 container2

实例

启动一个会立即退出的容器:

docker run --name test_container ubuntu bash -c “exit 5”

使用 docker wait 命令等待容器退出并获取退出代码:

docker wait test_container

输出：

此命令等待 test_container 退出，并返回退出代码 5。

启动多个会立即退出的容器:

1 2	docker run --name test_container1 ubuntu bash -c "exit 1" docker run --name test_container2 ubuntu bash -c "exit 2"

使用 docker wait 命令等待多个容器退出并获取它们的退出代码:

docker wait test_container1 test_container2

输出：

1
2

1
2

此命令等待 test_container1 和 test_container2 退出，并返回它们的退出代码 1 和 2。

注意事项

docker wait 命令会阻塞直到容器停止，因此在长时间运行的容器上使用时需要注意。
该命令仅返回容器的退出代码，不提供其他关于容器的状态或输出的信息。

docker wait 命令是一个简单但非常有用的工具，允许用户等待容器停止并获取其退出代码。通过该命令，用户可以轻松地在脚本中实现任务同步和自动化操作。使用 docker wait 命令，可以确保在指定的容器完成其任务之前，不会进行任何后续操作。

Docker export 命令

docker export 命令用于将 Docker 容器的文件系统导出为一个 tar 归档文件。

docker export 命令主要用于备份或迁移容器的文件系统，而不包括 Docker 镜像的所有层和元数据。

语法

docker export [OPTIONS] CONTAINER

OPTIONS说明：

-o, --output: 将输出保存到指定文件，而不是输出到标准输出。

导出容器文件系统:

docker export my_container

将名为 my_container 的容器的文件系统导出到标准输出。

将导出文件保存为 tar 文件:

docker export my_container > my_container_backup.tar

将容器 my_container 的文件系统导出并保存到 my_container_backup.tar 文件中。

使用 --output 选项保存导出文件:

shdocker export -o my_container_backup.tar my_container

将容器 my_container 的文件系统导出并保存到 my_container_backup.tar 文件中。

实例

启动一个容器:

docker run -d --name my_container ubuntu bash -c "echo hello > /hello.txt && sleep 3600"

导出容器的文件系统:

docker export my_container > my_container_backup.tar

查看导出的 tar 文件内容:

tar -tf my_container_backup.tar

输出：

hello.txt

导入文件系统到新的容器:

cat my_container_backup.tar | docker import - my_new_image

注意事项

docker export 只导出容器的文件系统，不包括 Docker 镜像的层、元数据或运行时信息。
如果容器正在运行，导出的文件系统将是容器当前状态的快照。
导出的 tar 文件可能会很大，具体取决于容器的文件系统大小。

docker export 命令是一个有用的工具，用于将容器的文件系统导出为 tar 归档文件。这对于备份、迁移和分析容器的文件系统非常有用。通过使用 --output 选项，用户可以将导出内容保存为指定文件，方便管理和使用。

Docker port 命令

docker port 命令用于显示容器的端口映射信息，即容器内部的端口如何映射到宿主机的端口。

docker port 命令对于了解容器如何与宿主机网络交互非常有用。

语法

docker port CONTAINER [PRIVATE_PORT[/PROTO]]

CONTAINER: 要查询端口映射的容器的名称或 ID。
PRIVATE_PORT (可选): 容器内部的端口号。
PROTO (可选): 协议类型（tcp 或 udp），默认是 tcp。

查看容器的所有端口映射:

docker port my_container

显示名为 my_container 的容器的所有端口映射信息。

查看特定端口的映射:

docker port my_container 80

显示名为 my_container 的容器内部的端口 80 映射到宿主机的哪个端口。

查看特定端口和协议的映射:

docker port my_container 80/tcp

显示名为 my_container 的容器内部的 TCP 端口 80 映射到宿主机的哪个端口。

实例

启动一个容器并映射端口:

docker run -d -p 8080:80 --name my_container nginx

此命令将 my_container 容器的端口 80 映射到宿主机的端口 8080。

查看容器的端口映射:

docker port my_container

输出：

80/tcp -> 0.0.0.0:8080

显示容器的端口 80 映射到宿主机的 8080 端口。

查看特定端口的映射:

docker port my_container 80

输出：

0.0.0.0:8080

注意事项

docker port 命令仅显示端口映射信息，不会显示容器内部运行的服务的状态或其他信息。
如果容器没有暴露任何端口，或者没有进行端口映射，docker port 命令将不会返回任何信息。

docker port 命令是一个用于查看容器端口映射的工具，帮助用户了解容器的端口如何映射到宿主机。通过使用这个命令，用户可以方便地检查和调试容器的网络配置。

Docker stats 命令

docker stats 命令用于实时显示 Docker 容器的资源使用情况，包括 CPU、内存、网络 I/O 和块 I/O。

docker stats 似于 Linux 系统中的 top 命令，但它专门针对 Docker 容器。通过 docker stats，用户可以监控容器的资源使用情况，帮助优化性能和进行故障排除。

语法

docker stats [OPTIONS] [CONTAINER...]

OPTIONS 说明：

–all , -a :显示所有的容器，包括未运行的。
–format :指定返回值的模板文件。
–no-stream :展示当前状态就直接退出了，不再实时更新。
–no-trunc :不截断输出。

显示所有运行的容器的资源使用情况:

docker stats

显示指定容器的资源使用情况:

docker stats my_container

显示所有容器（包括未运行的容器）的资源使用情况:

docker stats --all

只显示一次数据而不是持续刷新:

docker stats --no-stream

使用自定义格式输出:

docker stats --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}"

实例

列出所有在运行的容器信息。

runoob@runoob:~$  docker stats
CONTAINER ID        NAME                                    CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
b95a83497c91        awesome_brattain                        0.28%               5.629MiB / 1.952GiB   0.28%               916B / 0B           147kB / 0B          9
67b2525d8ad1        foobar                                  0.00%               1.727MiB / 1.952GiB   0.09%               2.48kB / 0B         4.11MB / 0B         2
e5c383697914        test-1951.1.kay7x1lh1twk9c0oig50sd5tr   0.00%               196KiB / 1.952GiB     0.01%               71.2kB / 0B         770kB / 0B          1
4bda148efbc0        random.1.vnc8on831idyr42slu578u3cr      0.00%               1.672MiB / 1.952GiB   0.08%               110kB / 0B          578kB / 0B          2

输出详情介绍：

CONTAINER ID 与 NAME: 容器 ID 与名称。

CPU % 与 MEM %: 容器使用的 CPU 和内存的百分比。

MEM USAGE / LIMIT: 容器正在使用的总内存，以及允许使用的内存总量。

NET I/O: 容器通过其网络接口发送和接收的数据量。

BLOCK I/O: 容器从主机上的块设备读取和写入的数据量。

PIDs: 容器创建的进程或线程数。

根据容器等 ID 或名称现实信息：

runoob@runoob:~$ docker stats awesome_brattain 67b2525d8ad1

CONTAINER ID        NAME                CPU %               MEM USAGE / LIMIT     MEM %               NET I/O             BLOCK I/O           PIDS
b95a83497c91        awesome_brattain    0.28%               5.629MiB / 1.952GiB   0.28%               916B / 0B           147kB / 0B          9
67b2525d8ad1        foobar              0.00%               1.727MiB / 1.952GiB   0.09%               2.48kB / 0B         4.11MB / 0B         2

以 JSON 格式输出：

1
2

runoob@runoob:~$ docker stats nginx --no-stream --format "{{ json . }}"
  {"BlockIO":"0B / 13.3kB","CPUPerc":"0.03%","Container":"nginx","ID":"ed37317fbf42","MemPerc":"0.24%","MemUsage":"2.352MiB / 982.5MiB","Name":"nginx","NetIO":"539kB / 606kB","PIDs":"2"}

输出指定的信息：

runoob@runoob:~$ docker stats --all --format "table {{.Container}}\t{{.CPUPerc}}\t{{.MemUsage}}" fervent_panini 5acfcb1b4fd1 drunk_visvesvaraya big_heisenberg
  {"BlockIO":"0B / 13.3kB","CPUPerc":"0.03%","Container":"nginx","ID":"ed37317fbf42","MemPerc":"0.24%","MemUsage":"2.352MiB / 982.5MiB","Name":"nginx","NetIO":"539kB / 606kB","PIDs":"2"}

CONTAINER                CPU %               MEM USAGE / LIMIT
fervent_panini           0.00%               56KiB / 15.57GiB
5acfcb1b4fd1             0.07%               32.86MiB / 15.57GiB
drunk_visvesvaraya       0.00%               0B / 0B
big_heisenberg           0.00%               0B / 0B

常用场景

实时监控: 实时查看容器的资源使用情况，以便进行性能监控和优化。
故障排除: 在容器出现问题时，检查资源使用情况，帮助排查问题根源。
资源管理: 监控容器的资源使用情况，确保资源分配合理，避免资源浪费或瓶颈。

docker stats 命令是一个强大的工具，用于实时监控 Docker 容器的资源使用情况。通过该命令，用户可以获取容器的 CPU、内存、网络 I/O 和块 I/O 的详细信息，帮助进行性能优化、故障排除和资源管理。

Docker update 命令

docker update 命令用于更新 Docker 容器的资源限制，包括内存、CPU 等。

docker update命令可以在容器运行时动态调整资源限制，而不需要停止和重新启动容器。

语法

docker update [OPTIONS] CONTAINER [CONTAINER...]

常用参数

CONTAINER：要更新资源限制的容器名称或容器 ID。你可以指定一个或多个容器。
OPTIONS：用于指定需要更新的资源限制。

常用选项 OPTIONS：

1、--memory, -m：设置容器的内存限制。

格式：[]
例如：500m、2g 等。

docker update -m 2g my_container

2、--memory-swap：设置容器的内存和交换空间（swap）的总限制。如果设置为 -1，表示不限制交换空间。

格式：[]，如 2g，或 -1 表示无限制。

docker update --memory-swap 3g my_container

3、--cpu-shares：设置容器的 CPU 优先级，相对值。默认为 1024，较大的值表示较高的优先级。

该选项不会直接限制容器的 CPU 使用量，而是控制 CPU 资源分配的优先级。

docker update --cpu-shares 2048 my_container

4、--cpus：设置容器使用的 CPU 核心数。这个选项可以限制容器最多使用的 CPU 核心数。

格式：，例如：1.5 表示最多使用 1.5 个 CPU 核心。

docker update --cpus 2 my_container

5、--cpu-period：设置 CPU 周期时间。用于配合 --cpu-quota 限制容器的 CPU 使用时间。单位是微秒（默认值：100000 微秒 = 100ms）。

docker update --cpu-period 50000 my_container

6、--cpu-quota：设置容器在每个周期内可以使用的最大 CPU 时间。单位是微秒。需要与 --cpu-period 配合使用。

docker update --cpu-quota 25000 my_container

7、--blkio-weight：设置块 I/O 权重（范围：10 到 1000），表示容器对磁盘 I/O 操作的优先级。默认值为 500。

docker update --blkio-weight 800 my_container

8、--pids-limit：设置容器可以使用的最大进程数。

格式：，例如：100。

docker update --pids-limit 200 my_container

9、--restart：设置容器的重启策略（no、on-failure、always、unless-stopped）。

docker update --restart always my_container

实例

更新容器的内存限制：

docker update -m 2g my_container这条命令将 my_container 的内存限制更新为 2GB。

设置 CPU 核心数限制：

docker update --cpus 1.5 my_container

这条命令将 my_container 限制为最多使用 1.5 个 CPU 核心。

更新容器的 CPU 权重：

docker update --cpu-shares 1024 my_container

这条命令将容器的 CPU 权重设置为 1024，默认值就是 1024。

更新容器的块 I/O 权重：

docker update --blkio-weight 700 my_container

这条命令将容器的磁盘 I/O 权重设置为 700，权重范围是 10 到 1000。

使用限制

docker update 命令会立即生效，但并不会影响容器内运行的应用程序，容器继续保持运行状态。
仅支持调整容器的资源限制，对于其他容器配置（如环境变量、端口映射等）无法修改。

Docker命令-容器生命周期管理

2025-01-15T04:12:12.000Z

Docker run 命令

docker run 命令用于创建并启动一个新的容器。

语法

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

常用参数说明：

-d: 后台运行容器并返回容器 ID。
-it: 交互式运行容器，分配一个伪终端。
--name: 给容器指定一个名称。
-p: 端口映射，格式为 host_port:container_port。
-v: 挂载卷，格式为 host_dir:container_dir。
--rm: 容器停止后自动删除容器。
--env 或 -e: 设置环境变量。
--network: 指定容器的网络模式。
--restart: 容器的重启策略（如 no、on-failure、always、unless-stopped）。
-u: 指定用户。

实例

基本使用

docker run ubuntu

拉取 ubuntu 镜像并在前台启动一个容器。

后台运行容器

docker run -d ubuntu

在后台运行 ubuntu 容器并返回容器 ID。

交互式运行并分配终端

docker run -it ubuntu /bin/bash

以交互模式运行 ubuntu 容器，并启动一个 Bash shell。

指定容器名称

docker run --name my_container ubuntu

运行一个 ubuntu 容器，并将其命名为 my_container。

端口映射

docker run -p 8080:80 nginx

将本地主机的 8080 端口映射到容器内的 80 端口，运行 nginx 容器。

挂载卷

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

将主机的 /host/data 目录挂载到容器内的 /container/data 目录。

设置环境变量

docker run -e MY_ENV_VAR=my_value ubuntu

设置环境变量 MY_ENV_VAR 的值为 my_value，运行 ubuntu 容器。

使用网络模式

docker run --network host nginx

使用主机的网络模式运行 nginx 容器。

指定重启策略

docker run --restart always nginx

设置容器的重启策略为 always，即使容器停止也会自动重启。

指定用户

docker run -u user123 ubuntu

以 user123 用户运行 ubuntu 容器。

组合多个选项

docker run -d -p 8080:80 -v /host/data:/data --name webserver nginx

后台运行一个命名为 webserver 的 nginx 容器，将主机的 8080 端口映射到容器的 80 端口，并将主机的 /host/data 目录挂载到容器的 /data 目录。

Docker start/stop/restart 命令

docker start 命令用于启动一个或多个已经创建的容器。

docker stop 命令用于停止一个运行中的容器。

docker restart 命令用于重启容器。

docker start 命令

语法

docker start [OPTIONS] CONTAINER [CONTAINER...]

参数

-a: 附加到容器的标准输入输出流。
-i: 附加并保持标准输入打开。

实例

启动一个容器:

docker start my_container

启动名称为 my_container 的容器。

启动并附加到容器:

docker start -a my_container

启动容器并附加到它的标准输入输出流。

同时启动多个容器:

docker start container1 container2 container3

同时启动 container1、container2 和 container3 容器。

docker stop 命令

语法

docker stop [OPTIONS] CONTAINER [CONTAINER...]

参数

-t, --time: 停止容器之前等待的秒数，默认是 10 秒。

实例

停止一个容器:

docker stop my_container

停止名称为 my_container 的容器。

指定等待时间停止容器:

docker stop -t 30 my_container

等待 30 秒后停止容器。

同时停止多个容器:

docker stop container1 container2 container3

同时停止 container1、container2 和 container3 容器。

docker restart 命令

语法

docker restart [OPTIONS] CONTAINER [CONTAINER...]

参数

-t, --time: 重启容器之前等待的秒数，默认是 10 秒。

实例

重启一个容器:

docker restart my_container

重启名称为 my_container 的容器。

指定等待时间重启容器:

docker restart -t 15 my_container

等待 15 秒后重启容器。

同时重启多个容器:

docker restart container1 container2 container3

同时重启 container1、container2 和 container3 容器。

Docker kill 命令

docker kill 命令用于立即终止一个或多个正在运行的容器。

与 docker stop 命令不同，docker kill 命令会直接发送 SIGKILL 信号给容器的主进程，导致容器立即停止，而不会进行优雅的关闭。

语法

docker kill [OPTIONS] CONTAINER [CONTAINER...]

OPTIONS说明：

-s, --signal: 发送给容器的信号（默认为 SIGKILL）。

常用信号

SIGKILL: 强制终止进程（默认信号）。
SIGTERM: 请求进程终止。
SIGINT: 发送中断信号，通常表示用户请求终止。
SIGHUP: 挂起信号，通常表示终端断开。

实例

立即终止一个容器:

docker kill my_container

立即终止名称为 my_container 的容器。

发送自定义信号:

docker kill -s SIGTERM my_container

向名称为 my_container 的容器发送 SIGTERM 信号，而不是默认的 SIGKILL 信号。

同时终止多个容器:

docker kill container1 container2 container3

立即终止 container1、container2 和 container3 容器。

docker kill 命令用于立即终止一个或多个正在运行的容器，通过发送信号（默认 SIGKILL）给容器的主进程实现。与 docker stop 不同，docker kill 不会等待容器优雅地停止，而是直接终止进程。该命令在需要快速停止容器时非常有用，但应谨慎使用以避免数据损失或不一致。

Docker rm 命令

docker rm 命令用于删除一个或多个已经停止的容器。

docker rm 命令不会删除正在运行的容器，如果你需要先停止容器，可以使用 docker stop 命令。

语法

docker rm [OPTIONS] CONTAINER [CONTAINER...]

CONTAINER [CONTAINER...]: 一个或多个要删除的容器的名称或 ID。

OPTIONS说明：

-f, --force: 强制删除正在运行的容器（使用 SIGKILL 信号）。
-l, --link: 删除指定的连接，而不是容器本身。
-v, --volumes: 删除容器挂载的卷。

删除单个容器：

docker rm

你可以一次性删除多个容器，只需将容器 ID 或名称用空格分隔：

docker rm ...

你可以使用以下命令来删除所有已停止的容器：

docker container prune这个命令会提示你确认删除所有已停止的容器。

实例

假设你有以下两个容器：

1
2
3

CONTAINER ID        IMAGE          COMMAND             CREATED             STATUS              PORTS      NAMES
abcd1234            nginx         "nginx -g 'daemon…" 2 minutes ago       Exited (0) 1 minute ago        my_nginx
efgh5678            redis        "redis-server"      3 minutes ago       Exited (0) 2 minutes ago       my_redis

你可以使用以下命令删除它们：

docker rm abcd1234 efgh5678

或者，你可以使用容器名称删除它们：

docker rm my_nginx my_redis

删除所有已经停止的容器：

docker rm $(docker ps -a -q)

杀死所有正在运行的容器

docker kill $(docker ps -a -q)

删除所有未打 dangling 标签的镜像

docker rmi $(docker images -q -f dangling=true)

通过镜像的id来删除指定镜像

docker rmi

删除所有镜像

docker rmi $(docker images -q)

为这些命令创建别名

# ~/.bash_aliases

# 杀死所有正在运行的容器.
alias dockerkill='docker kill $(docker ps -a -q)'

# 删除所有已经停止的容器.
alias dockercleanc='docker rm $(docker ps -a -q)'

# 删除所有未打标签的镜像.
alias dockercleani='docker rmi $(docker images -q -f dangling=true)'

# 删除所有已经停止的容器和未打标签的镜像.
alias dockerclean='dockercleanc || true && dockercleani'

Docker pause/unpause 命令

docker pause 和 docker unpause 命令用于暂停和恢复容器中的所有进程。

docker pause - 暂停容器中所有的进程。

docker unpause - 恢复容器中所有的进程。

暂停的容器不会被终止，但其进程将被挂起，直到容器被恢复。这在需要临时暂停容器活动的情况下非常有用。

docker pause 命令

docker pause 命令用于暂停一个或多个容器中的所有进程。

语法

docker pause CONTAINER [CONTAINER...]

实例

暂停一个容器：

docker pause my_container

暂停名称为 my_container 的容器中的所有进程。

暂停多个容器：

docker pause container1 container2

同时暂停 container1 和 container2 容器中的所有进程。

docker unpause 命令

docker unpause 命令用于恢复一个或多个已暂停容器中的所有进程。

语法

docker unpause CONTAINER [CONTAINER...]

实例

恢复一个容器：

docker unpause my_container

恢复名称为 my_container 的容器中的所有进程。

恢复多个容器：

docker unpause container1 container2

同时恢复 container1 和 container2 容器中的所有进程。

使用场景

临时暂停活动: 当需要临时暂停容器中的所有活动以进行系统维护或资源管理时，可以使用 docker pause。
资源管理: 在需要重新分配系统资源时，暂停不必要的容器以释放资源。
调试和故障排除: 在调试或故障排除过程中暂停容器以分析当前状态。

总结

docker pause: 用于暂停容器中的所有进程。暂停的容器仍然存在，但其进程将挂起，直到恢复。
docker unpause: 用于恢复已暂停容器中的所有进程，使其恢复正常运行。

Docker create 命令

docker create 命令用于创建一个新的容器，但不会启动它。

docker create 命令会根据指定的镜像和参数创建一个容器实例，但容器只会在创建时进行初始化，并不会执行任何进程。

用法同 [docker run]。

语法

docker create [OPTIONS] IMAGE [COMMAND] [ARG...]

常用参数

--name: 给容器指定一个名称。
-p, --publish: 端口映射，格式为 host_port:container_port。
-v, --volume: 挂载卷，格式为 host_dir:container_dir。
-e, --env: 设置环境变量。
--network: 指定容器的网络模式。
--restart: 容器的重启策略（如 no、on-failure、always、unless-stopped）。
-u, --user: 指定用户。
--entrypoint: 覆盖容器的默认入口点。
--detach: 在后台创建容器。

实例

创建一个容器：

docker create ubuntu

根据 ubuntu 镜像创建一个容器，但不会启动它。

创建并指定容器名称：

docker create --name my_container ubuntu

创建一个名为 my_container 的容器，但不会启动它。

创建并设置环境变量：

docker create -e MY_ENV_VAR=my_value ubuntu

创建一个容器，并设置环境变量 MY_ENV_VAR 的值为 my_value。

创建并挂载卷：

docker create -v /host/data:/container/data ubuntu

创建一个容器，并将主机的 /host/data 目录挂载到容器的 /container/data 目录。

创建并端口映射：

docker create -p 8080:80 nginx

创建一个容器，将本地主机的 8080 端口映射到容器的 80 端口，但不会启动它。

创建并指定重启策略：

docker create --restart always nginx

创建一个容器，并将重启策略设置为 always。

创建并指定用户：

docker create -u user123 ubuntu

创建一个容器，并以 user123 用户运行容器。

查看容器

在创建容器之后，可以使用 docker ps -a 命令查看所有容器，包括已创建但未启动的容器。

docker ps -a

启动已创建的容器

使用 docker start 命令来启动已创建但未启动的容器：

docker start my_container

总结

docker create: 用于创建一个新的容器实例但不启动它。可以通过各种参数设置容器的配置。
docker start: 启动已创建的容器，使其开始运行。

docker create 命令允许用户预先配置容器的设置，并在需要时手动启动容器，这对于自动化部署和测试场景特别有用。

Docker exec 命令

docker exec 命令用于在运行中的容器内执行一个新的命令。这对于调试、运行附加的进程或在容器内部进行管理操作非常有用。

语法

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

常用参数

-d, --detach: 在后台运行命令。
--detach-keys: 覆盖分离容器的键序列。
-e, --env: 设置环境变量。
--env-file: 从文件中读取环境变量。
-i, --interactive: 保持标准输入打开。
--privileged: 给这个命令额外的权限。
--user, -u: 以指定用户的身份运行命令。
--workdir, -w: 指定命令的工作目录。
-t, --tty: 分配一个伪终端。

实例

在容器内运行命令：

docker exec my_container ls /app

在运行中的 my_container 容器内执行 ls /app 命令，列出 /app 目录的内容。

以交互模式运行命令：

docker exec -it my_container /bin/bash

在运行中的 my_container 容器内启动一个交互式的 Bash shell。-i 保持标准输入打开，-t 分配一个伪终端。

在后台运行命令：

docker exec -d my_container touch /app/newfile.txt

在运行中的 my_container 容器内后台执行 touch /app/newfile.txt 命令，创建一个新文件。

设置环境变量：

docker exec -e MY_ENV_VAR=my_value my_container env

在运行中的 my_container 容器内执行 env 命令，并设置环境变量 MY_ENV_VAR 的值为 my_value。

以指定用户身份运行命令：

docker exec -u user123 my_container whoami

在运行中的 my_container 容器内以 user123 用户身份执行 whoami 命令。

指定工作目录：

docker exec -w /app my_container pwd

在运行中的 my_container 容器内以 /app 目录为工作目录执行 pwd 命令。

使用场景

调试容器: 进入容器内部进行调试和排查问题。
管理任务: 在容器内运行附加的管理任务或维护操作。
监控和检查: 在容器内执行监控和检查命令，获取运行状态和日志。

总结

docker exec 命令是 Docker 中非常强大的工具，允许用户在运行中的容器内执行额外的命令。这对于调试、管理和维护容器非常有用，能够帮助用户更灵活地控制和操作容器内部的环境。

Docker rename 命令

docker rename 命令用于重命名已存在的容器。该命令允许你在不停止或删除容器的情况下，直接修改容器的名称。

语法

docker rename <当前容器名称或ID> <新容器名称>

常用参数说明：

当前容器名称或ID：需要修改名称的现有容器的名称或者 ID。
新容器名称：将容器重命名为指定的新名称。这个名称必须唯一，不能与其他正在运行的容器冲突。

实例

1、重命名容器

假设有一个正在运行的容器，名称为 my_old_container，并且需要将它重命名为 my_new_container：

docker rename my_old_container my_new_container

执行成功后，容器的名称将变为 my_new_container。你可以通过以下命令确认：

docker ps -a

2、使用容器 ID 重命名

如果你不知道容器的名称，但知道其 ID，可以使用容器的 ID 来重命名。例如：

docker rename 123abc456def my_new_container

同样，123abc456def 是容器的 ID，重命名后可以通过 docker ps -a 查看。

3、检查是否重名

如果你尝试重命名的名称已经被其他容器使用，Docker 会返回错误：

docker rename my_old_container existing_container_name

输出：

Error response from daemon: Conflict. The container name "/existing_container_name" is already in use by container "abc123". You have to remove (or rename) that container to be able to reuse that name.

此时需要先重命名或移除 existing_container_name 的容器，然后再进行操作。

Docker安装

2025-01-05T08:56:13.000Z

启动Docker

1 2	sudo systemctl start docker # service docker start

停止docker：

1	systemctl stop docker

重启docker：

1	systemctl restart docker

Linux系统安装docker

ubuntu安装docker

1	sudo apt update && sudo apt upgrade -y

准备条件

#安装前先卸载操作系统默认安装的docker，
sudo apt-get remove docker docker-engine docker.io containerd runc

#安装必要支持
sudo apt install apt-transport-https ca-certificates curl software-properties-common gnupg lsb-release

准备安装

# 添加 Docker 官方 GPG key （可能国内现在访问会存在问题）
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 阿里源（推荐使用阿里的gpg KEY）
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加 apt 源:
# Docker官方源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 阿里apt源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 更新源
sudo apt update && sudo apt upgrade -y

安装docker

# 安装最新版本的Docker
sudo apt install docker-ce docker-ce-cli containerd.io
# 等待安装完成
# 查看Docker版本
sudo docker version

# 查看Docker运行状态
sudo systemctl status docker

卸载docker

删除安装包：

1	sudo apt-get purge docker-ce

删除镜像、容器、配置文件等内容：

1	sudo rm -rf /var/lib/docker

Windows系统安装docker

进入docker官网下载

检查docker版本

1	docker --version

运行测试容器

1	docker run hello-world

Docker安装MySQL

拉取MySQL镜像

默认拉取最新版本MySQL

1	docker pull mysql

拉取指定版本MySQL5.7

1	sudo docker pull mysql:5.7

查看MySQL镜像版本

1	docker search mysql

查看已安装镜像

1	docker images

启动MySQL容器

启动最新版本

docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:latest

启动指定版本（以MySQL5.7为例）

sudo docker run -p 3306:3306 --name mysql \
-v /mydata/mysql/log:/var/log/mysql \
-v /mydata/mysql/data:/var/lib/mysql \
-v /mydata/mysql/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-d mysql:5.7

进入MySQL容器

查看MySQL进程[CONTAINER ID]

1	docker ps -a

启动MySQL

1 2	docker run [CONTAINER ID] # docker run --name mysql5.7 -e MYSQL_ROOT_PASSWORD=123456 -p 3307:3306 -d mysql:5.7

进入MySQL容器

1	docker exec -it mysql bash

MySQL基本

1	mysql -u root -p

查看MySQL日志

1	docker logs mysql5.7

MySQL远程控制

命令：use mysql;
命令：select host,user from user;
命令：ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
命令：flush privileges;

把root用户的密码改成 mysql_native_password 模式，即可远程连接

#创建一个账号-admin，用来进行远程访问；
CREATE USER 'admin'@'%' IDENTIFIED BY '123456';
 
 赋予所有权限给之前创建的账号:admin
GRANT ALL ON *.* TO 'admin'@'%';
 
 确认使用密码{123456}登录此账号{admin}
 密码尽量复杂，安全性更高。
ALTER USER 'admin'@'%' IDENTIFIED WITH mysql_native_password BY '123456';
 
 刷新权限
FLUSH PRIVILEGES;

Docker安装Ubuntu

安装centos7系统同下

拉取最新版的 Ubuntu 镜像

1 2	docker pull ubuntu # 或者 docker pull ubuntu:latest

运行Ubuntu容器

查看本地ubuntu镜像

1	docker images

运行ubuntu容器

1	docker run -itd --name ubuntu-test ubuntu

进入ubuntu容器

1	docker exec -it ubuntu-test /bin/bash

Docker安装Tomcat

拉取镜像Tomcat:8

1	docker pull tomcat:8

查看Tomcat版本

1	docker search tomcat

运行Tomcat容器

docker run -it -p 8080:8080 --name=tomcat tomcat:8
# docker run --name tomcat -p 8080:8080 -v
# docker run --name tomcat-test -p 8080:8080 -v /usr/local/project:/usr/local/tomcat/webapps --privileged=true -d tomcat

进入Tomcat容器

1	docker exec -it tomcat /bin/bash

web程序运行

1	cd /usr/local/

1	mkdir -p /project/web

新建index.html文件并写入内容

vim /usr/local/project/myweb/index.html 
 <HTML>
   <h1>
     Holl Tomcat!

Hive函数

2025-01-04T02:51:30.000Z

系统内置函数

查看系统自带的函数

hive> show functions; 
OK 
tab_name 
abs 
……

显示自带的函数的用法

hive> desc function abs; 
OK 
tab_name 
abs(x) - returns the absolute value of x

详细显示自带的函数的用法

hive> desc function extended abs; 
OK 
tab_name 
abs(x) - returns the absolute value of x 
Example: 
  > SELECT abs(0) FROM src LIMIT 1; 
  0 
  > SELECT abs(-5) FROM src LIMIT 1; 
  5 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDFAbs 
Function type:BUILTIN

常用内置函数

空字段赋值-NVL（防止空字段参与计算）

函数说明

hive(default)> desc function extended nvl; 
OK 
tab_name 
nvl(value,default_value) - Returns default value if value is null else returns value 
Example: 
  > SELECT nvl(null,'bla') FROM src LIMIT 1; 
  bla 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDFNvl 
Function type:BUILTIN

解释：

NVL：	给值为NULL的数据赋值，它的格式是NVL( value，default_value)。
功能：	如果value为NULL，则NVL函数返回default_value的值，否则返回value的值如果两个参数都为NULL ，则返回NULL。

案例实操

数据准备：采用员工表

查询：

如果员工的comm为NULL，则用0代替

hive (default)> select ename,comm,nvl(comm, 0) comm_0 from emp; 
OK 
ename   comm            comm_0 
fanfan  500000.0      500000.0 
SMITH   NULL           0 
ALLEN   300.0          300.0 
WARD    500.0          500.0 
……

如果员工的job为NULL，则用领导id代替

hive (default)> select ename, mgr,comm, nvl(job,mgr) comm_mgr from emp; 
OK 
job  _c1 
研发 研发 
财务 财务 
行政 行政 
销售 销售 
研发 研发 
研发 研发 
NULL mgr 
行政 行政 
销售 销售 
销售 销售 
行政 行政 
讲师 讲师 
行政 行政 
讲师 讲师

CASE WHEN THEN ELSE END

函数说明

1	hive (default)> desc function extended case;

解释：根据不同数据，返回不同的值

如：CASE a WHEN b THEN c [WHEN d THEN e]* [ELSE f] END 当a=b时，返回c；当a=d时，返回d；当a=e时，放回e；其他情况返回f。

案例实操

数据准备，在/opt/module/hive/datas目录下创建emp_sex.txt，添加如下内容

[root@hadoop datas]$ vim emp_sex.txt 
悟空,A,男 
大海,A,男 
宋宋,B,男 
凤姐,A,女 
婷姐,B,女 
婷婷,B,女

创建emp_sex表并导入数据

hive(default)> create table emp_sex( 
name string,  
dept_id string,  
sex string 
)  
row format delimited fields terminated by ","; 
hive(default)> load data local inpath '/opt/module/hive/datas/emp_sex.txt' into table emp_sex;

需求：求出不同部门男女各多少人。结果如下：

1
2
3

dept_id   man_num   woman_num 
A          2          1 
B          1          2

按需求查询数据

hive(default)> select  
  dept_id, 
  sum(case sex when '男' then 1 else 0 end) man_num, 
  sum(case sex when '女' then 1 else 0 end) woman_num 
from  
  emp_sex 
group by  dept_id;

行转列

相关函数说明

CONCAT(string A/col, string B/col…)：返回输入字符串连接后的结果，支持任意个输入字符串;

hive (default)> desc function extended concat; 
OK 
tab_name 
concat(str1, str2, ... strN) - returns the concatenation of str1, str2, ... strN or concat(bin1, 
bin2, ... binN) - returns the concatenation of bytes in binary data  bin1, bin2, ... binN 
Returns NULL if any argument is NULL. 
Example: 
  > SELECT concat('abc', 'def') FROM src LIMIT 1; 
  'abcdef' 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDFConcat 
Function type:BUILTIN

CONCAT_WS(separator, str1, str2,…)：

hive (default)> desc function extended concat_ws; 
OK 
tab_name 
concat_ws(separator, [string | array(string)]+) - returns the concatenation of the strings 
separated by the separator. 
Example: 
  > SELECT concat_ws('.', 'www', array('facebook', 'com')) FROM src LIMIT 1; 
  'www.facebook.com' 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDFConcatWS 
Function type:BUILTIN

- 它是一个特殊形式的 CONCAT()。第一个参数剩余参数间的分隔符。- 分隔符可以是与剩余参数一样的字符串。- 如果分隔符是 NULL，返回值也将为 NULL。- 这个函数会跳过分隔符参数后的任何 NULL 和空字符串。- 分隔符将被加到被连接的字符串之间;-  注意: CONCAT_WS must be "string or array

COLLECT_SET(col)：

hive (default)> desc function extended collect_set; 
OK 
tab_name 
collect_set(x) - Returns a set of objects with duplicate elements eliminated 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDAFCollectSet 
Function type:BUILTIN

- 函数只接受基本数据类型- 它的主要作用是将某字段的值进行去重汇总，产生array类型字段。

COLLECT_LIST(col):

- 函数指接收基本数据类型- 它的主要作用是将某字段的值进行不去重汇总，产生array类型字段。

数据准备

name	constellation	blood_type
孙悟空	白羊座	A
大海	射手座	A
宋宋	白羊座	B
猪八戒	白羊座	A
凤姐	射手座	A
苍老师	白羊座	B

案例需求：把星座和血型一样的人归类到一起。结果如下：

1
2
3

射手座,A            大海|凤姐 
白羊座,A            孙悟空|猪八戒 
白羊座,B            宋宋|苍老师

数据准备：在/opt/module/hive/datas目录下创建文件constellation.txt，添加如下内容

[root@hadoop datas]$ vim person_info.txt 
孙悟空,白羊座,A 
大海,射手座,A 
宋宋,白羊座,B 
猪八戒,白羊座,A 
凤姐,射手座,A 
苍老师,白羊座,B

案例实操

创建person_info表并导入数据

hive (default)> create table person_info( 
name string,  
constellation string,  
blood_type string 
)  
row format delimited fields terminated by ",";

导入数据到person_info表中。

1 2	hive (default)> load data local inpath "/opt/module/hive/datas/person_info.txt" into table person_info;

按需求查询数据

hive (default)> SELECT 
t1.c_b, 
CONCAT_WS("|",collect_set(t1.name)) 
FROM ( 
SELECT 
NAME , 
CONCAT_WS(',',constellation,blood_type) c_b 
FROM person_info 
)t1  
GROUP BY t1.c_b

列转行

函数说明

EXPLODE(col)：将hive表的一列中复杂的array或者map结构拆分成多行。

hive (default)> desc function extended explode; 
OK 
tab_name 
explode(a) - separates the elements of array a into multiple rows, or the elements of a map into 
multiple rows and columns  
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDTFExplode 
Function type:BUILTIN

SPLIT(string str, string regex): 按照regex字符串分割str，会返回分割后的字符串数组

hive (default)> desc function extended split; 
OK 
tab_name 
split(str, regex) - Splits str around occurances that match regex 
Example: 
  > SELECT split('oneAtwoBthreeC', '[ABC]') FROM src LIMIT 1; 
  ["one", "two", "three"] 
Function class:org.apache.hadoop.hive.ql.udf.generic.GenericUDFSplit 
Function type:BUILTIN

LATERAL VIEW

用法：LATERAL VIEW udtf(expression) tableAlias AS columnAlias

解释：用于和split, explode等UDTF一起使用，它能够将一列数据拆成多行数据，在此基础上可以对拆分后的数据进行聚合。lateral view首先为原始表的每行调用UDTF，UDTF会报一行拆分成一行或者多行， lateral view再把结果组合，产生一个支持别名表的虚拟表。

案例需求：将表中的categroy列的数据展开。

movie	category
《疑犯追踪》	悬疑,动作,科幻,剧情
《Lie to me》	悬疑,警匪,动作,心理,剧情
《战狼2》	战争,动作,灾难

结果如下：

《疑犯追踪》      悬疑 
《疑犯追踪》      动作 
《疑犯追踪》      科幻 
《疑犯追踪》      剧情 
《Lie to me》   悬疑 
《Lie to me》   警匪 
《Lie to me》   动作 
《Lie to me》   心理 
《Lie to me》   剧情 
《战狼2》        战争 
《战狼2》        动作 
《战狼2》        灾难

案例实操

在/opt/module/hive/datas/目录下创建文件movie.txt，添加如下数据：

[root@hadoop datas]$ vim movie_info.txt 
《疑犯追踪》 悬疑,动作,科幻,剧情 
《Lie to me》 悬疑,警匪,动作,心理,剧情 
《战狼2》 战争,动作,灾难

创建hive表并导入数据

hive (default)> create table movie_info( 
    movie string,  
    category string)  
row format delimited 
fields terminated by "\t"; 
hive (default)> load data local inpath "/opt/module/hive/datas/movie_info.txt" into table 
movie_info;

按需求查询数据

hive (default)> SELECT movie,category_name  
FROM movie_info  
lateral VIEW 
explode(split(category,",")) movie_info_tmp  AS category_name ;

窗口函数（开窗函数）

开窗函数介绍
- 窗口函数不同于我们熟悉的常规函数及聚合函数，它输入多行数据（一个窗口），为每行数据进行一次计算，返回一个值。
- 灵活运用窗口函数可以解决很多复杂的问题，如去重、排名、同比及和环比、连续登录等。

语法：

1	Function（arg1 ……） over（[partition by arg1 ……] [order by arg1 ……] [<window_expression>]）

Function		Over()		window_expression
解释：	支持的函数	解释：	指定分析函数工作的数据窗口大小，窗口会随着行的变化而变化。	解释：	窗口边界的设置
聚合函数：	sum()、max()、 min()、avg() 等。	Partition by:	表示将数据先按字段进行分区	n preceding	往前n行
				n following	往后n行
排序函数：	rank()， row_number()、 dens_rank()、 ntile()等。			current row	当前行
		Order by:	表示将各个分区内的数据按字段进行排序	unbounded preceding	从前面的起点开始
	lead()、 lag()、 first_value() 等。			unbounded following	到后面的终点结束

使用详解
- 如果不指定partition by，则不对数据进行分区，换句话说，所有数据看作同一个分区。
- 如果不指定order by，则不对各分区进行排序，通常用于那些顺序无关的窗口函数，如sum（）。
- 如果不指定窗口子句：

不指定order by，默认使用分区内所有行，等同于Function() over(rows between unbounded precedeing and unbounded following) 如果指定order by，默认使用分区内第起点到当前行，等同于Function() over(rows between unbounded preceding and current row)

数据准备

在/opt/module/hive/datas目录下创建business.txt，添加如下内容。

[root@hadoop datas]$ vim business.txt 
jack,2017-01-01,10 
tony,2017-01-02,15 
jack,2017-02-03,23 
tony,2017-01-04,29 
jack,2017-01-05,46 
jack,2017-04-06,42 
tony,2017-01-07,50 
jack,2017-01-08,55 
mart,2017-04-08,62 
mart,2017-04-09,68 
neil,2017-05-10,12 
mart,2017-04-11,75 
neil,2017-06-12,80 
mart,2017-04-13,94

创建hive表并导入数据

hive(default)> create table business( 
name string,  
orderdate string, 
cost int 
) 
ROW FORMAT DELIMITED 
FIELDS TERMINATED BY ','; 
hive(default)> load data local inpath "/opt/module/hive/datas/business.txt" into table business;

Rank

函数说明

RANK()：排序相同时会重复，总数不会变重复的名次一样但是下一名名次会以前面人数+1来定

DENSE_RANK()：排序相同时会重复，总数会减少就是若有重复则最后一名的名次不会和总数相等即并列

ROW_NUMBER()：会根据顺序计算，字段相同就按排头字段继续排

数据准备

在/opt/module/hive/datas目录下创建文件score.txt，添加如下内容

[root@hadoop datas]$ vim score.txt 
孙悟空 语文 87 
孙悟空 数学 95 
孙悟空 英语 68 
大海 语文 94 
大海 数学 56 
大海 英语 84 
宋宋 语文 64 
宋宋 数学 86 
宋宋 英语 84 
婷婷 语文 65 
婷婷 数学 85 
婷婷 英语 78

创建表score并导入数据

hive(default)> create table score( 
name string, 
subject string,  
score int)  
row format delimited 
fields terminated by "\t"; 
hive(default)> load data local inpath '/opt/module/hive/datas/score.txt' into table score;

需求：计算每门学科成绩排名。

hive(default)> select name, 
subject, 
score, 
rank() over(partition by subject order by score desc) rp, 
dense_rank() over(partition by subject order by score desc) drp, 
row_number() over(partition by subject order by score desc) rmp 
from score; 
OK 
name    subject score   rp      drp     rmp 
孙悟空  数学    95      1       1       1 
宋宋    数学    86      2       2       2 
婷婷    数学    85      3       3       3 
大海    数学    56      4       4       4 
宋宋    英语    84      1       1       1 
大海    英语    84      1       1       2 
婷婷    英语    78      3       2       3 
孙悟空  英语    68      4       3       4 
大海    语文    94      1       1       1 
孙悟空  语文    87      2       2       2 
婷婷    语文    65      3       3       3 
宋宋    语文    64      4       4       4

自定义函数

内置函数：Hive 自带了一些函数。比如：max/min等，但是数量有限，自己可以通过自定义UDF来方便的扩展。
自定义函数：当Hive提供的内置函数无法满足你的业务处理需要时此时就可以考虑使用用户自定义函数（UDF：user-defined function）。
根据用户自定义函数类别分为以下三种：

UDF（User-Defined-Function）–> 一进一出

UDAF（User-Defined Aggregation Function） --> 聚合函数，多进一出，类似：count/max/min

UDTF（User-Defined Table-Generating Functions）–> 炸裂函数，一进多出，如：explode()

官方文档地址https://cwiki.apache.org/confluence/display/Hive/HivePlugins
编程步骤：

继承Hive提供的类

1 2	·org.apache.hadoop.hive.ql.udf.generic.GenericUDF ·org.apache.hadoop.hive.ql.udf.generic.GenericUDTF;

实现类中的抽象方法
实现类中的抽象方法

自定义UDF函数

需求:自定义一个UDF实现计算给定字符串的长度，例如：

1
2
3

hive(default)> select my_len("abcd"); 
ok 
4

案例实操

创建一个Maven工程Hive
在工程项目的pom.xml文件中导入依赖

<dependencies> 
  <dependency> 
   <groupId>org.apache.hivegroupId> 
   <artifactId>hive-execartifactId> 
   <version>3.1.2version> 
  dependency> 
dependencies>

创建一个类

package com.atguigu.hive; 
 
import org.apache.hadoop.hive.ql.exec.UDFArgumentException; 
import org.apache.hadoop.hive.ql.exec.UDFArgumentLengthException; 
import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
import org.apache.hadoop.hive.ql.metadata.HiveException; 
import org.apache.hadoop.hive.ql.udf.generic.GenericUDF; 
import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; 
import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; 
 
/** 
 * 自定义UDF函数，需要继承GenericUDF类 
 * 需求: 计算指定字符串的长度 
 */ 
public class MyStringLength extends GenericUDF { 
    /** 
     * 
     * @param arguments 输入参数类型的鉴别器对象 
     * @return 返回值类型的鉴别器对象 
     * @throws UDFArgumentException 
     */ 
    @Override 
    public ObjectInspector initialize(ObjectInspector[] arguments) throws UDFArgumentException { 
        // 判断输入参数的个数 
        if(arguments.length !=1){ 
            throw new UDFArgumentLengthException("Input Args Length Error!!!"); 
        } 
        // 判断输入参数的类型 
        if(!arguments[0].getCategory().equals(ObjectInspector.Category.PRIMITIVE)){ 
            throw new UDFArgumentTypeException(0,"Input Args Type Error!!!"); 
        } 
        //函数本身返回值为int，需要返回int类型的鉴别器对象 
        return PrimitiveObjectInspectorFactory.javaIntObjectInspector; 
    } 
 
    /** 
     * 函数的逻辑处理 
     * @param arguments 输入的参数 
     * @return 返回值 
     * @throws HiveException 
     */ 
    @Override 
    public Object evaluate(DeferredObject[] arguments) throws HiveException { 
       if(arguments[0].get() == null){ 
           return 0 ; 
       } 
       return arguments[0].get().toString().length(); 
    } 
 
    @Override 
    public String getDisplayString(String[] children) { 
        return ""; 
    } 
}

打成jar包上传到服务器/opt/module/hive/datas/myudf.jar
将jar包添加到hive的classpath

1	hive (default)> add jar /opt/module/hive/datas/myudf.jar;

创建临时函数

创建临时函数与开发好的java class关联

1	hive (default)> create temporary function my_len as "com.atguigu.hive. MyStringLength";

在hql中使用自定义的函数

hive (default)> select ename,my_len(ename) ename_len from emp; 
OK 
ename   _c1 
fanfan  6 
SMITH   5 
ALLEN   5 
WARD    4 
JONES   5 
MARTIN  6 
BLAKE   5 
CLARK   5 
SCOTT   5 
KING    4 
TURNER  6 
ADAMS   5 
JAMES   5 
FORD    4 
MILLER  6

注意：临时函数只跟会话有关系，跟库没有关系，只要创建临时函数的会话不断，再当前会话下，任意一个库都可以使用，其他会话全部不能使用。

创建永久函数

注意：因为add jar的方式本身也是临时生效，所以在创建永久函数的时候，需要执行路径（应且因为元数据的原因，这个路径还得是HDFS上的路径）

hive (default)>  
create function my_len2  
as "com.atguigu.hive.udf.MyUDF"  
using jar "hdfs://hadoop102:8020/udf/myudf.jar";

即可在hql中使用自定义的永久函数

hive (default)>  
select  
    ename, 
    my_len2(ename) ename_len  
from emp;

删除永久函数

1	hive (default)> drop function my_len2;

注意：永久函数跟会话没有关系，创建函数的会话断了以后，其他会话也可以使用。

永久函数创建的时候，在函数名之前需要自己加上库名，如果不指定库名的话，会默认把当前库的库名给加上。

永久函数使用的时候，需要在指定的库里面操作,或者在其他库里面使用的话加上库名.函数名。

年度总结 | 2025

2024-12-31T16:00:00.000Z

荏苒韶华，若白驹过隙，已是碧玉年华。

冷若霜冻，微风簌簌，我踏着寂静的小路，脚步轻盈。抬头仰望那皓月，它悬挂在夜空中，皎洁无暇，如同打磨过的玉石，散发着柔和的光辉。你好呀，年少的我，还有遥远的未来我。我们在不同的时间、不同的地点，隔着时空的鸿沟相互凝望。回顾这一年，我仿佛已经半只脚踏入了成年人的世界。生活的重压似乎在不知不觉中磨平了我的棱角，我变得忙碌而机械，许多事情不再去思考其背后的意义，只是机械地为了完成而完成。我对未来感到迷茫，它既像是无尽的黑洞，又像是一条笔直却一眼望得到尽头的道路。

上半年的情感之路颇为坎坷，爱情如同泡沫，绚烂却易碎。网络上的忠贞不渝与现实中的背叛交织，让我对爱情逐渐麻木，不禁自嘲地笑出声来。

迷茫、彷徨、堕落、懒惰、逃避、麻木，这些词汇似乎成了我下半年的生活写照。我不清楚自己究竟想要什么，是遵循父母的期望，还是听从专业人士的建议。但似乎，我总是在倾听他人的声音，却从未真正聆听自己内心的呼唤。我幻想一夜暴富，然后过上无忧无虑的生活，但突然间，我意识到这样的生活似乎失去了意义。家庭关系并不和谐，真心朋友虽有几个，却因忙碌而少有交流，情感上也没有找到真正合适的伴侣。我不禁设想，我会不会最终孤独终老，这个问题，或许只能留给未来去解答。

人啊，总是不可避免地走向孤独。

今年的成就，似乎难以一一记起。最近通过的华为证书，算是一点微不足道的成绩吗？我已经记不太清了。身体的懒惰让我疏于运动，连文字的表达也变得生疏起来。然而，对于明年，我有一个唯一的要求：我要倾听自己的声音，活出真正的自己。不再随波逐流，不再迷失在别人的期望中，我要找到属于自己的道路，让自己的生活充满色彩和意义。

SQL Server(草稿版)

2024-12-04T09:30:00.000Z

SQL Server

基本介绍：美国Microsoft公司推出的一种关系型数据库系统。SQL Server是一个可扩展的、高性能的、为分布式客户机/服务器计算所设计的数据库管理系统，实现了与WindowsNT的有机结合，提供了基于事务的企业级信息管理系统方案。

服务的启动方式：

命令行：net start mssqlserver
任务管理器：找到服务再找到mssqlserver
右击此电脑打开管理：

打开SQL server管理工具的方式：

在开始菜单搜索：SSMS(SQL Server Management Studio)

连接不到数据库的原因：

服务没有开启
密码或账号错误
防火墙没有关闭
网络原因（没有使用tcp/ip协议在SQL server配置管理器里面打开网络配置然后开启tcpip协议）

身份验证

windows身份验证：

使用windows账号登录

混合身份验证(sqlserver的身份验证模式和windows身份验证)：

既可以用windows账号登录也可以用SQL server的登录名登录

设置身份验证：

版本

Microsoft SQL Server Management Studio10.50.6000.34
Microsoft Analysis Services 客户端工具 10.50.6000.34
Microsoft 数据访问组件 (MDAC) 10.0.19041.4291
Microsoft MSXML 3.0 6.0
Microsoft Internet Explorer 9.11.19041.0
Microsoft .NET Framework 2.0.50727.9174
操作系统 6.3.19045

端口号：1433

SQL server的用户和角色

在SQL server数据里面分为两种级别分别是服务器级别和数据库级别

服务器级别

为帮助您管理服务器上的权限，SQL Server 提供了若⼲角色，这些角色是⽤于对其他主体进⾏分组的安全主体。服务器级角色的权限作⽤域为服务器范围。SQL Server 提供了九种固定服务器角色，⽆法更改授予固定服务器角色的权限，这9组角色分别如下：

sysadmin —— 在SQL Server中进⾏任何活动，该角色的权限跨越所有其它固定服务器角色

serveradmin —— 更改服务器范围内的配置选项并关闭服务器

setupadmin —— 添加和删除链接服务器，并执⾏某些系统存储过程（如 sp_serveroption）

securityadmin —— 授予数据库引擎的访问权限和配置⽤户权限的能⼒使得安全管理员可以分配⼤多数服务器权限，securityadmin 角色应视为与sysadmin 角色等效

processadmin —— 管理在 SQL Server 实例中运⾏的进程

dbcreator —— 创建和改变数据库，但是没有读取权限

diskadmin —— 管理磁盘⽂件

bulkadmin —— 执⾏ BULK INSERT 语句

public —— 每个 SQL Server 登录名均属于 public 服务器角色。如果未向某个服务器主体授予或拒绝对某个安全对象的特定权限，该⽤户将继承授予该对象的 public 角色的权限。当您希望该对象对所有⽤户可⽤时，只需对任何对象分配 public 权限即可。您⽆法更改 public 中的成员关系。public 的实现⽅式与其他角色不同，但是，可以从 public 授予、拒绝或撤销权限。

注意：

>>登录名⼀定属于某些角色，默认为public

**>>**服务器角色不容许更改

**>>**登录后也不⼀定有权限操作数据库

数据库角色

数据库角色：SQL Server 中有两种类型的数据库级角色：数据库中预定义的**“固定数据库角色”和您可以创建的“灵活数据库角色”**

固定的有某些权限的数据库角色，所有数据库中都有这些角色，默认有10个，分别如下；

public

–public 角色是⼀个特殊的数据库角色，每个数据库⽤户都属于它。public 角色：

**>>**捕获数据库中⽤户的所有默认权限。

**>>**⽆法将⽤户、组或角色指派给它，因为默认情况下它们即属于该角色。

**>>**包含在每个数据库中，包括 master、msdb、tempdb、model 和所有⽤户数据库。

**>>**⽆法除去。

db_owner

**–**进⾏所有数据库角色的活动，以及数据库中的其它维护和配置活动。

**–**该角色的权限跨越所有其它固定数据库角色。

db_accessadmin

**–**在数据库中添加或删除 Windows NT 4.0 或 Windows 2000 组和⽤户以及 SQL Server ⽤户。

db_datareader

**–**查看来⾃数据库中所有⽤户表的全部数据。

db_datawriter

**–**添加、更改或删除来⾃数据库中所有⽤户表的数据

db_ddladmin

**–添加、修改或除去数据库中的对象(**运⾏所有 DDL)

db_securityadmin

**–**管理 SQL Server 2000 数据库角色的角色和成员，并管理数据库中的语句和对象权限

db_backupoperator

**–**有备份数据库的权限

db_denydatareader

**–**拒绝选择数据库数据的权限

db_denydatawriter

**–**拒绝更改数据库数据的权限

数据库角色具体位置在数据库**——>某个具体库——>安全性——>角色——>**数据库角色

SQL server架构

架构：架构（Schema）是⼀组数据库对象的集合，它被单个负责⼈（可以是⽤户或角色）所拥有并构成唯⼀命名空间。可以将架构看成是对象的容器。

**>>**数据库⽤户对应于服务器登录名以便登录者可以操作数据库

**>>**数据库角⾊可以添加，可以定制不同权限

**>>**数据库架构，类似于数据库对象的命名空间，⽤户通过架构访问数据库对象

服务器级 -> 数据库级 -> 架构级 - > 数据对象级

注意：

⼀个⽤户可以拥有多个架构，但是不能对没有拥有的架构进⾏操作。⼀个数据库角色，是对不同架构⾥

⾯数据对象的权限组织，也有可能涉及到多个架构，当某⼀个⽤户被转换成⼀种数据库角色的时候，假如这个⽤户本⾝不拥有某⼀个架构⽽该数据库角色拥有，那当它对那个架构进⾏操作的时候就会出错。

相互之间的关系

登录名与数据库⽤户在服务器级别是⼀对多的，在数据库级别是⼀对⼀的⼀个登录名可以和多个不同库下的⽤户做映射，但是在同⼀个库下只能和⼀个⽤户做映射，并且⼀个⽤户名可以和多个登录名有映射关系，真正有权限的是⽤户名，只不过是⽤登录名去登进数据库，然后去找映射的⽤户名，这样就有了相应的权限，刚开始建⽴的登录名只要把该登录名的服务器角⾊设置为Database Creator，就可以创建新的数据库了，并且新建⽴的这个数据库中会⾃动⽣成两个⽤户名：dbo和guest。并且刚刚建⽴的登录名就和dbo映射了，还有就是rbo也和sa映射了，因为sa作为管理员的登录名和每个库中的rbo⽤户映射。
⼀个数据库角色有可能涉及多个架构，数据库角色对应的是权限
⼀个⽤户对应⼀个数据库角色
⼀个数据库⽤户可以对应多个架构（架构是表容器），架构⾥⾯包含的是数据库表。

SQL server系统库

SQL Server提供了四个系统数据库，包括master、msdb、model和tempdb。

master系统数据库存储SQL Server实例的系统级信息。
msdb数据库由SQL Server代理用于作业和警报。
model数据库用作创建其他数据库的模板。
tempdb系统数据库存储临时对象，并在每次SQL Server启动时重新创建。

TRANSAC-SQL (T-SQL)

标识符

SQL Server的所有对象，包括服务器、数据库以及数据库对象，如表、视图、列、索引、触发器、存储过程、规则、默认值和约束等都可以有一个标识符。就是对象的名字。

数据库对象的全名应该由服务器名、数据库名、拥有者名和对象名这四个部分组成，格式如下：

[[[server.][database].][owner_name].]object_name 命名必须都要符合标识符的规定。

命名规则

规则标识符：符合标识符命名规则的

标识符不允许是T-SQL的保留字（T-SQL不区分大小写所以不论是大小写的保留字都不能使用）

标识符内部不允许有空格或特殊字符（例如[],‘’）

首字母命名规则
- 英文大小写A-z
- 其他语言，比如汉字
- 特殊符号：_，@，#
首字母之后
- 英文大小写A-z
- 数字0-9
- 其他语言，比如汉字
- 特殊符号：_、@、#、$

界定标识符：可以不符合标识符命名规则，但是用界定符号包裹起来的

界定符号：[]或者是’’

注：无论是界定标识符还是规则标识符都最多只能容纳128个字符，对于本地的临时表最多可以有116个字符。

以某些特殊符号开头的标识符在SQL Server系统中具有特定的含义

@：局部变量用户自己定义的

@@：全局变量系统定义和维护的

#：局部临时表

##：全局临时表

全局变量	说明
@@error	上一条SQL语句报告的错误号
@@nestlevel	当前存储过程或触发器的嵌套级别
@@rowcount	上一条SQL语句处理的行数
@@servername	本地服务器名称
@@identity	最后插入的标识值
@@spid	当前用户进程的会话id
@@fetch_status	上一条游标fetch语句的状态
@@cpu_busy	SQL Server自上次启动后的时间状态

SQL server创建数据库

数据库文件包括：数据文件(mdf)和日志文件(ldf)

use master
go

if exists(select * from sysdatabases where name='sql_wei')    -- 判断数据库是否存在
begin
    print '数据库已存在，现在开始删除--------------------'
    drop database sql_wei
    print '数据库删除成功，结束删除----------------------'
end
else
begin
    create database sql_wei
    on primary(
    name='sql_wei',   -- 文件的逻辑名称
    filename='D:\Program Files\Microsoft SQL Server\MSSQL10_50.MSSQLSERVER\data\sql_wei.mdf', --文件的路径
    size=5mb, -- 初始化大小
    maxsize=100mb, -- 最大的大小
    filegrowth=5%  -- 自增率
    )
    log on(
    name='sql_wei_log',
    filename='D:\Program Files\Microsoft SQL Server\MSSQL10_50.MSSQLSERVER\data\sql_wei_log.ldf',
    size=5mb,
    maxsize=100mb,
    filegrowth=5%
)
end
go

自增属性

identity：标识列 identity(起始值,每次增长值)

关于主键、候选键、超键

理解超键、候选键、主键概念及关系
1.基本概念
超键(super key):在关系中能唯一标识元组的属性集称为关系模式的超键/码。
候选键(candidate key):不含有多余属性的超键称为候选键，即其真子集不再是超键。
主键(primary key):用户选作元组标识的一个候选键称为主键，是候选键之一。
2.关系
候选键是超键的子集，主键是候选键中的一个。
3.例子:
考虑属性集（身份证号，姓名，性别，年龄），假设无重名
a.其中超键有：身份证号、姓名、（姓名，性别）、（姓名，性别，年龄）等
–这里可以看出，超键是能唯一确定一个人的属性组

b.超键中的候选键身份证号、姓名唯一，而且没有多余属性，所以是一个候选键
–这里可以看出，候选键是没有多余属性的超键
c.选择主键用户可根据自己喜好考虑选择姓名或者身份证号作为主键
–主键是选中的一个候选键

约束

主键 primary key
默认 default
非空 not null
检查 check
外键 foreign key
唯一 unique

数据类型

第一大类:整数数据

bit:bit数据类型代表0,1或NULL,就是表示true,false.占用1byte.
int:以4个字节来存储正负数.可存储范围为:-2^31至231-1.
smallint:以2个字节来存储正负数.存储范围为:-2^15至215-1
tinyint: 是最小的整数类型,仅用1字节,范围:0至此2^8-1

第二大类:精确数值数据

numeric:表示的数字可以达到38位,存储数据时所用的字节数目会随着使用权用位数的多少变化.
decimal:和numeric差不多

第三大类:近似浮点数值数据

float:用8个字节来存储数据.最多可为53位.范围为:-1.79E+308至1.79E+308.
real:位数为24,用4个字节,数字范围:-3.04E+38至3.04E+38

第四大类:日期时间数据

datetime:表示时间范围可以表示从1753/1/1至9999/12/31,时间可以表示到3.33/1000秒.使用8个字节.
smalldatetime:表示时间范围可以表示从1900/1/1至2079/12/31.使用4个字节.

第五大类:字符串数据

char:长度是设定的,最短为1字节,最长为8000个字节.不足的长度会用空白补上.
varchar:长度也是设定的,最短为1字节,最长为8000个字节,尾部的空白会去掉.
text:长宽也是设定的,最长可以存放2G的数据.

第六大类:Unincode字符串数据

nchar:长度是设定的,最短为1字节,最长为4000个字节.不足的长度会用空白补上.储存一个字符需要2个字节.
nvarchar:长度是设定的,最短为1字节,最长为4000个字节.尾部的空白会去掉.储存一个字符需要2个字节.
ntext:长度是设定的,最短为1字节,最长为2G.尾部的空白会去掉,储存一个字符需要2个字节.

第七大类:货币数据类型

money:记录金额范围为:-92233720368577.5808至92233720368577.5807.需要8 个字节.
smallmoney:记录金额范围为:-214748.3648至214748.36487.需要4个字节.

第八大类:标记数据

timestamp:该数据类型在每一个表中是唯一的!当表中的一个记录更改时,该记录的timestamp字段会自动更新.
uniqueidentifier:用于识别数据库里面许多个表的唯一一个记录.

第九大类:二进制码字符串数据

binary:固定长度的二进制码字符串字段,最短为1,最长为8000.

image:为可变长度的二进制码字符串,最长2G.

varbinary:与binary差异为数据尾部是00时,varbinary会将其去掉

SQL server语法操作、

运算符号

算数运算符
- +、-、*、\、%
拼接运算符
```
  * 
```
比较运算符
- <、>、=、>=、<=、<>，!=
赋值运算符
- = --赋值方式 set 和 select
逻辑运算符
- and、or、not

运算符优先级：()>算术运算符>比较运算符>逻辑运算符(not>and>or)>拼接运算符>赋值运算符

DDL（data definition language） – 数据定义语言

对库内的所有对象的结构做操作的语法称为数据定义语言–定义对象结构

[] ---------- 代表可以写也可以省略

create – 创建

数据内的所有对象(表-table、视图-view、存储过程-procedrue、存储函数-function、触发器-trigger、用户user、数据库-database等等)都可以用create创建

基本语法：create 对象关键字名字;

创建表的语法：create table 表名(

列名列类型 [约束]，

…

列名列类型 [约束] – 最后一个列不需要，隔开

)；

自增：标识列，identity(起始值，增长值)

约束 – 六大约束都可以用作维护和保证数据一致性和完整性

主键约束（primary key）:用来标识数据行，唯一并且非空，一个主键可以是多个列的组合也可以是一个列，但是表里只能有一个主键。
唯一约束（unique）：可以为空，但是数据必须没有重复
非空约束（not null）：不可以为空
检查约束（check）：检查添加或修改的数据符合规则
默认约束（default）：当添加或修改时没有给定值，就会填入默认值
外键约束（foreign key）：连接另外一个表保证数据一致，有外键的表叫做子表，被连接的表叫父表，子表的外键列可以重复，但是父表被连接的列不可以重复，删除数据是先删除子表的数据再删除父表的数据

DROP – 删除

drop 对象关键字对象名; – 不可以撤销

truncate table 表名; – 清空表数据不可撤销

Alter – 修改

语法：alter table 表名 …

添加约束：

create table StudentInfo(
    ID int not null identity(1,1),--编号
    Number char(10) not null,--学号
    Name varchar(20) not null,--姓名
    Sex char(2) null,--性别
    Age int,--年龄
    Birthday date,--出生日期
    Address varchar(50),--家庭住址
    Class varchar(10)--班级
)

create table Score(
    Number char(10) not null ,--学号
    Subject varchar(20) not null,--科目
    Score decimal(4,1)--分数
)

– 删除约束
alter table studentinfo drop constraint st_pk
– 添加主键约束
alter table studentinfo add constraint st_pk primary key (id)
– 外键约束
alter table score add constraint st_fk foreign key (number) references studentinfo(number)
– 唯一
alter table studentinfo add constraint st_uk unique (number)
– 检查
alter table studentinfo add constraint st_ck check (age between 6 and 18)
– 默认
alter table studentinfo add constraint st_dk default ‘男’ for sex
– 非空
alter table studentinfo alter column address varchar(50) not null

DML – 数据操纵语言

insert

insert into 表名 values (所有列的数据除去identity列),…

insert into 表名 select ‘李平’,‘男’,18

insert into 表名 (指定列) values (指定列数据)，…

update

update 表名 set 列=值 where 条件

delete

delete from 表名 where 条件

select

复制表：select * into 表2 from 表1；复制表1给表2 会表结构和表数据

函数

https://learn.microsoft.com/zh-cn/sql/t-sql/functions/cursor-rows-transact-sql?view=sql-server-2016

转换函数 convert(数据类型(长度),表达式[,n])

例子：select convert(nvarchar(32),getdate(),120) – （目标数据类型，要转换的数据，格式代码）

不带世纪数位	带世纪数位	格式
1	101	mm/dd/yyyy
2	102	yy.mm.dd
3	103	dd/mm/yyyy
4	104	dd.mm.yy
5	105	dd-mm-yy
8	108	hh:mi:ss
	20或120	yyyy-mm-dd hh:mi::ss(24h)
23（-）	111（/）	yyyy/mm/dd

CONVERT 函数支持广泛的数据类型转换，包括整数、浮点数、日期、时间、字符串等。你可以根据具体的需求选择合适的数据类型和样式。

需要注意的是，CONVERT 函数执行显式的数据类型转换，而在某些情况下可能会导致数据截断或格式错误。在使用 CONVERT 函数时，要确保转换操作符合目标数据类型的规范，并小心处理可能出现的错误情况。

数学函数

T-SQL中提供的常用的数学函数如下：

· abs()：返回绝对值

· round(数值表达式,长度,[,类型])：舍入到指定长度或精度。类型为0，表示舍入，类型为非0，表示截断

· power(m,n)：返回m的n次幂

· trunc()：将数字截断到指定的位数 *

· %：求余数，SQL Server没有mod(m,n)，而用m%n代替取模

      ceiling()：向上取整函数  floor()

字符串函数

· ltrim(str,substr)/rtrim(str,substr)：str表示要操作的字符串，substr表示要裁剪的子串，若裁剪空格，则可以省略

· substring(str,position,length)：截取字符串

· replace(str,search_str,rep_str)：替换一个字符串中的子串。search_str表示要搜索的子字符串，rep_str表示要替换的目标字符串

· left(str,n)：返回字符串从左边开始的指定个数的字符

· right(str,n)：返回字符串从右边开始的指定个数的字符

· len()：求字符串长度

日期和时间函数

首先列出日期时间函数中的重要参数。

日期时间元素	缩写	含义
year	yy,yyyy	年
month	m,mm	月
day	d,dd	日
dayofyear	dy	年的天数
week	wk	星期数
weekday	dw	星期几
hour	hh	时
minute	mi	分
quarter	qq	季
second	ss	秒
millisecond	ms	毫秒

T-SQL中提供下列日期函数：

· getdate()：返回当前的日期和时间 – mysql中的now()

· year(日期)：返回指定日期的“年”部分的整数

· month(日期)：返回指定日期的“月”部分的整数

· day(日期)：返回指定日期的“日”部分的整数

· datepart(日期元素，日期)：返回日期元素指定的日期部分的整数

· datename(日期元素，日期)：以字符串的形式返回日期元素指定时间的日期名称

· datediff(日期元素，日期1，日期2)：返回两个日期间的差值并将其转换为指定日期元素的形式

· dateadd(日期元素，数值，日期) ：按照“日期元素”给定的日期单位，返回“日期”加上“数值”的新日期

涉及日期时间常量时，SQL Server建议使用与dateformat及语言环境设置无关的字符串格式，通常这样的字符串常量符合下面两种形式：

· 日期之间不使用分隔符，格式为yyyymmdd[ hh:mi:[:ss][,mmm]]，如’20070703’，‘20070703 17:53:00.997’。

· ISO 8601标准形式，格式为yyyy-mm-ddThh:mi:ss[.mmm]，日期各个部分之间使用“-”分隔符，日期和时间部分用T分隔，并且时间部分不能省略，如’2007-07-03T17:53:10’。

批处理-GO

批处理是指从应用程序一次性地发送一组完整SQL语句到SQL Server上执行。

批处理的所有语句被当作一个整体，被成批地分析，编译和执行。

所有的批处理指令以GO作为结束的标志

GO的特点:

1、GO语句必须自成一行，只有注释可以在同一行上

2、每个批处理单独发送到服务器

3、GO语句不是T-SQL命令

事务-TRANSACTION

概念：成批的sql语句要么全部执行，要么全部不执行；

特点：

原子性：事务是数据库的逻辑工作单位。不可分割，要么全部都做要么都不做
一致性：从一个正确的状态到另外一个正确的状态
隔离性：事务与事务之间互不干扰
持久性：事务一旦提交，结果就是永久的

事务和批的区别

编程时，一定要区分事务和批的差别。

1）批是一组整体编译的SQL语句，事务是一组作为单个逻辑工作单元执行的SQL语句。

2）批语句的组合发生在编译时刻，事务中语句的组合发生在执行时刻。

3）当在编译时，批中某个语句存在语法错误，系统将取消整个批中所有语句执行，而在运行时刻，如果事务中某个数据修改违反约束、规则等，系统默认只回退到产生该错误的语句。

影响事务正常运行的故障有
系统故障
介质故障
事务内部的故障
计算机病毒

事务分类

SQL Server 的默认事务隔离级别是“读已提交”（READ COMMITTED）

显式事务

就是有明确的开始和结束：开启事务：BEGIN TRANSACTION/TRAN设置事务节点：save transaction 名称提交事务：COMMIT TRANSACTION/TRAN  ,COMMIT WORK回滚事务：ROLLBACK TRANSACTION/TRAN ,ROLLBACK WORK

隐式事务

需要开启隐式事务：SET IMPLICIT_TRANSACTIONS ON -- 开启隐式事务没有明确的开始事务，事务提交之后默认开启下一个事务只有提交和回滚：COMMIT/ROLLBACK  TRANSACTION/TRAN

自动化事务

SQL server默认的事务模式：不需要自己开启或结束事务，默认自动提交

设置事务保存节点：SAVE TRANSACTION 事务名称 节点以下的是事务节点内的操作

事务个数全局变量：@@TRANCOUNT

回滚事务不能回滚指定事务只能回滚部分事务需要save tran 事务节点名回滚事务节点这一部分的事务

提交事务可以提交指定事务名但是不能提交部分事务

存储过程

概念：是一组预先编译的sql语句

 ⼀组为了完成特定功能的SQL语句集合，经编译后存储在数据库中，⽤户通过指定存储过程的名称并给出参数来执行。

Transact-SQL中的存储过程，非常类似于Java语言中的方法，它可以重复调用。当存储过程执行一次后，可以将语句缓存在内存中，这样下次执行的时候直接使用缓存中的语句。这样就可以提高存储过程的性能。

调用方式：exec

存储过程的优点

简化操作，提高了sql语句的重用性，减少了开发程序员的压力，增加了可移植性
减少操作过程中的失误，提高效率，执行速度快
减少网络传输量（客户端不需要把所有的 SQL 语句通过网络发给服务器）减轻网络负担
减少了 SQL 语句暴露在网上的风险，也提高了数据查询的安全性

SQL server的系统存储过程

都是以sp_开头

概念：系统存储过程是系统创建的存储过程，⽬的在于能够⽅便的从系统表中查询信息或完成与更新数据库表相关的管理任务或其他的系统管理任务。系统存储过程主要存储在master数据库中，以“sp”下划线开头的存储过程。尽管这些系统存储过程在master数据库中，但我们在其他数据库还是可以调用系统存储过程。有⼀些系统存储过程会在创建新的数据库的时候被⾃动创建在当前数据库中。

常用的系统存储过程

exec sp_databases; --查看数据库
exec sp_tables; --查看表 
exec sp_columns student;--查看列 
exec sp_helpIndex student;--查看索引 
exec sp_helpConstraint student;--约束 
exec sp_stored_procedures; 
exec sp_helptext 'sp_stored_procedures';--查看存储过程创建、定义语句 
exec sp_rename studentinfo,student -- 修改表名、索引（index）、列（column）
exec sp_rename 'richinfouser.id','rid','column'
exec sp_renamedb myTempDB, myDB;--更改数据库名称 
exec sp_defaultdb 'master', 'myDB';--更改登录名的默认数据库 
exec sp_helpdb;--数据库帮助，查询数据库信息 
exec sp_helpdb master;

判断存储过程是否存在的两种方式：

if exists(select * from sys.objects where name=‘存储过程名’ )

if (object_id(‘存储过程名’, ‘P’) is not null) --P是指定存储过程类型

无参无返

例子：create proc/procedure 过程名

存储过程体

有参无返

create proc proc_find_stu(
@id int – 入参
)
as
select * from students where id=@id; – 存储过程体

无参有返

create proc proc_find_stu1(
@id int output,
@name varchar(20) out
)
as
select @id=2,@name=name from students where id=@id
go

调用

declare
@id int=1,
@name varchar(20)
exec proc_find_stu1 @id output ,@name out
select @id ‘编号’,@name

有参有返

create proc proc_find_stu2(
@id int,
@name varchar(20) out
)
as
select @name=name from students where id=@id
go

调用

declare
@id int=2,
@name varchar(20)
exec proc_find_stu1 @id ,@name out
select @id ‘编号’,@name

sp_helptext是显示规则、默认值、未加密的存储过程、用户定义函数、触发器或视图的文本。

– with recomplie 不缓存

– with encryption 加密

分页存储过程 SQL server没有limit

分页sql：

select * from

(select *,row_number() over(order by 根据排序列 desc) 行号 from 表名) s

where s.行号 between 起始条 and 终止条;、

declare @page int–第几页
declare @count int–每页显示多少条
set @page = 4
set @count = 5
select top (@count) * from games where 游戏ID not in
(select top ((@page-1)*@count) 游戏ID from games

select top (@条数) * from 表名 where id not in (selecct top (@页数-1)*@条数) id from 表名

动态的执行sql

EXEC sp_executesql @stmt ,@params ,

@stmt = ,–-类似存储过程主体：需要执行的sql

@params = , —类似存储过程参数部分，入参、出参、出入参

—类似存储过程调用

例子：

set @sqlName='select @i = COUNT(0) from students';
exec sp_executesql @sqlName,N'@i int output',@i output

@sqlName：需要执行的sql

N'@i int output'：参数，相当于定义时候的参数 N开头意思为后⾯的数据类型为NChar或者NVarchar 使⽤N前缀 

@i output：相当于调用，调用之后就能获取到数据

异常处理–exception

raiserror：返回用户定义的错误信息，可以指定严重级别，设置系统变量记录所发生的错误。

RAISERROR ( { msg_id | msg_str | @local_variable }    
      { ,severity ,state }    
      [ ,argument [ ,...n ] ] 
     )    
  [ WITH option [ ,...n ] ]

第一个参数：{ msg_id | msg_str | @local_variable }

  msg_id：表示可以是一个sys.messages表中定义的消息代号；            使用 sp_addmessage 存储在 sys.messages 目录视图中的用户定义错误消息号。            用户定义错误消息的错误号应当大于 50000。 msg_str：表示也可以是一个用户定义消息，该错误消息最长可以有 2047 个字符；           （如果是常量，请使用N'xxxx'，因为是nvarchar的）            当指定 msg_str 时，RAISERROR 将引发一个错误号为 50000 的错误消息。 @local_variable：表示也可以是按照 msg_str 方式的格式化字符串变量。

第二个参数：severity

       用户定义的与该消息关联的严重级别。（这个很重要）          任何用户都可以指定 0 到 18 之间的严重级别。         [0,10]的闭区间内，不会跳到catch；          如果是[11,19],则跳到catch；          如果[20,无穷)，则直接终止 数据库 连接；

第三个参数：state

        如果在多个位置引发相同的用户定义错误，          则针对每个位置使用唯一的状态号有助于找到引发错误的代码段。          介于 1 至 127 之间的任意整数。（state 默认值为1）     当state 值为 0 或 javascript 大于 127 时会生成错误！

第四个参数：argument

        用于代替 msg_str 或对应于 msg_id 的消息中的定义的变量的参数。

第五个参数：option

        错误的自定义选项，可以是下表中的任一值：          LOG ：在错误日志和 应用 程序日志中记录错误；          NOWAIT：将消息立即发送给 客户 端；          SETERROR：将 @@ERROR 值和 ERROR_NUMBER 值设置为 msg_id 或 50000；

select * from sys.messages;

–使⽤sysmessages中定义的消息

raiserror(33003, 16, 1); raiserror(33006, 16, 1);

BEGIN TRY
print '123'
select 123              -- 可能会发生异常的代码快
select 1/0
END TRY
BEGIN CATCH
raiserror('1不能除以0',16,5)    -- 处理捕获的异常
END CATCH;

备份

全备份(完整备份)：创建备份完成时数据库内存在的数据的副本。
差异备份：只记录自上次数据库备份后发生更改的数据。差异数据库备份比数据库备份小，而且备份速度快，因此可以更经常地备份，经常备份将减少丢失数据的危险。
日志备份：是自上次备份事务日志后对数据库执行的所有事务的一系列记录。可以使用事务日志备份将数据库恢复到特定的即时点（如输入多余数据前的那一点）或恢复到故障点。
文件组备份：可以备份和还原数据库中的个别文件。可以只还原已损坏的文件，而不用还原数据库的其余部分，从而加快了恢复速度。

索引

聚集索引：聚集索引是索引结构和数据一起存放的索引。类似于字典的正文，当我们根据拼音直接就能找到那个字。
非聚集索引：非聚集索引是索引结构和数据分开存放的索引。类似于根据偏旁部首找字，首先找到该字所在的地址，再根据地址找到这个字的信息。

区别及优缺点

区别：

聚集索引一个表只能有一个，而非聚集索引一个表可以存在多个
聚集索引存储记录是物理上连续存在，而非聚集索引是逻辑上的连续，物理存储并不连续
聚集索引:物理存储按照索引排序；聚集索引是一种索引组织形式，索引的键值逻辑顺序决定了表数据行的物理存储顺序。
非聚集索引:物理存储不按照索引排序；非聚集索引则就是普通索引了，仅仅只是对数据列创建相应的索引，不影响整个表的物理存储顺序。
索引是通过二叉树的数据结构来描述的，我们可以这么理解聚簇索引：索引的叶节点就是数据节点。而非聚簇索引的叶节点仍然是索引节点，只不过有一个指针指向对应的数据块。

优势与缺点：

聚集索引插入数据时速度要慢（时间花费在“物理存储的排序”上，也就是首先要找到位置然后插入），查询数据比非聚集数据的速度快。

索引优化策略：

为经常用于查询条件的列创建索引。
对于频繁需要排序的列，可以创建索引以加速排序操作。
为经常需要更新的表创建索引时，考虑索引维护的代价。
对于有大量数据更新的表，避免在频繁更新的列上创建索引。
对于包含多个列的查询条件，创建复合索引，确保索引的列顺序与查询条件匹配。
使用特定的索引类型，如全文索引，适用于文本搜索。

-- 确保数据库已启用全文搜索功能
EXEC sp_fulltext_database 'enable';
 -- 创建一个全文目录
EXEC sp_fulltext_catalog 'MyFullTextCatalog', 'create';
 -- 为目标表启用全文索引支持
EXEC sp_fulltext_table 'MyTable', 'create', 'MyFullTextCatalog';
 -- 为表中的列指定全文索引列
EXEC sp_fulltext_column 'MyTable', 'MyColumn', 'add';
 -- 为全文目录填充改变
EXEC sp_fulltext_table 'MyTable', 'activate';
 -- 启动填充
EXEC sp_fulltext_catalog 'MyFullTextCatalog', 'start_full';

创建索引
create [unique|clustered|nonclustered] index 索引名 on 表(列,...)

删除索引
drop index 表.索引名

备份

完全备份（Full backup）：此备份类型包括整个数据库的所有数据和对象，可用于还原整个数据库到备份时的状态。完全备份需要较多的时间和存储空间。

差异备份（Differential backup）：差异备份只备份自上次完全备份或差异备份以来发生更改的数据和对象，可以更快地还原数据库到差异备份时的状态。

日志备份（Log backup）：日志备份仅备份自上次日志备份以来的事务日志，可以用于恢复到某个时间点或事务结束时的状态。

文件/文件组备份（File/Filegroup backup）：此备份类型是针对数据库的一部分，而不是整个数据库。可以对数据库中的一个或多个文件组进行备份，而不影响其他文件组。

部分备份（Partial backup）：部分备份是备份整个数据库的一部分，包括一组文件或一个文件组。这种备份类型用于在运行整个数据库的完全备份时，备份较大的数据库的子集。

mysql和sqlserver的区别

价格：MySQL是免费软件，而SQL Server需要购买授权，因此在使用成本上有所不同。
性能与扩展性：

SQL Server通常被认为是更适合大型企业级应用程序的选择，支持更大的数据量和更高的并发性能，可以更好地处理复杂的查询。
MySQL则更适合中小型应用程序，尤其是Web应用和小型企业使用，拥有更好的扩展性和灵活性。

安全性：

SQL Server提供了丰富的安全功能，包括高级的权限管理、加密和审计，对企业级应用程序的安全需求提供了良好的支持。3
MySQL的安全功能相对较少，但对于一般的应用程序来说已经足够。不过，也有观点认为MySQL的安全性相对较弱，需要额外注意数据备份和安全措施。

功能差异：

SQL Server对存储过程的支持更加完善，支持多种语言编写。
MySQL则支持多种存储引擎，给开发人员提供了很大的灵活性。

平台支持：

SQL Server是由微软公司开发的，主要适用于Windows操作系统。
MySQL则适用于多个操作系统，包括Windows、Linux和UNIX。

管理复杂性：

SQL Server的管理相对简单，可以由普通管理员进行管理。
MySQL的管理比较复杂，可能需要专业的DBA进行管理。

综上所述，MySQL和SQL Server各有优劣，选择哪个数据库软件主要取决于具体的应用场景和需求。例如，对于大型企业级应用，SQL Server可能更合适；而对于中小型网站和Web应用开发，MySQL可能更为适合。

Hive分区表和分桶表

2024-12-04T08:51:30.000Z

分区表

分区表实际上就是对应一个HDFS文件系统上的独立的文件夹。
该文件夹下是该分区所有的数据文件。
Hive中的分区就是分目录，把一个大的数据集根据业务需要分割成小的数据集。
在查询时通过WHERE子句中的表达式选择查询所需要的指定的分区，这样的查询效率会提高很多。

分区表基本操作

需要根据日期对日志进行管理，通过部门信息模拟
创建分区表语法

hive (default)>  
create table dept_partition( 
deptno int, --部门编号 
dname string, --部门名称 
loc string --部门位置 
) 
partitioned by (day string) 
row format delimited fields terminated by '\t';

注意：分区字段不能是表中已经存在的数据，可以将分区字段看作表的伪列。

数据准备

为每个分区准备数据，我们根据日期对日志进行管理，通过部门信息模拟

[root@hadoop datas]$ vim dept_20200401.log 
10 行政部 1700 
20 财务部 1800  
[root@hadoop datas]$ vim dept_20200402.log 
30 教学部 1900 
40 销售部 1700 
[root@hadoop datas]$ vim dept_20200403.log 
50 运营部 2000 
60 人事部 1900

案例实操
1. 向dept_partition表的分区加载数据

hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table 
dept_partition partition(day='20200401');  
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200402.log' into table 
dept_partition partition(day='20200402'); 
hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200403.log' into table 
dept_partition partition(day='20200403');

注意：分区表加载数据时，必须指定分区

2. 查询分区表中数据- 单分区查询

1	hive (default)> select * from dept_partition where day='20200401';

- 多分区联合查询（union 必走mr 效率较低）

hive (default)> select * from dept_partition where day='20200401' 
              union 
              select * from dept_partition where day='20200402' 
              union 
              select * from dept_partition where day='20200403'; 
hive (default)> select * from dept_partition where day='20200401' or 
                day='20200402' or day='20200403' ;

增加分区
1. 添加单个分区

1 2	hive (default)> alter table dept_partition add partition(day='20200404') ; hive (default)> show partitions dept_partition;

2. 同时添加多个分区

1
2
3

hive (default)> alter table dept_partition add partition(day='20200405') 
partition(day='20200406'); 
hive (default)> show partitions dept_partition;

删除分区
1. 删除单个分区

1 2	hive (default)> alter table dept_partition drop partition (day='20200406'); hive (default)> show partitions dept_partition;

2. 同时删除多个分区

1
2
3

hive (default)> alter table dept_partition drop partition (day='20200404'), 
partition(day='20200405'); 
hive (default)> show partitions dept_partition;

产看分区表结构

hive (default)> desc formatted dept_partition; 
# Partition Information           
# col_name              data_type               comment              
day                   string

二级分区

创建二级分区表

hive (default)>  
create table dept_partition2( 
       deptno int, 
       dname string, 
       loc string 
       )
partitioned by (day string, hour string) 
row format delimited fields terminated by '\t';

加载数据
1. 加载数据到二级分区表中

1 2	hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table dept_partition2 partition(day='20200401', hour='11');

2. 查询分区数据

1	hive (default)> select * from dept_partition2 where day='20200401' and hour='11';

让分区表和数据产生关联的三种方式
1. 方式一：上传数据后修复
- 上传数据

1
2
3

hive (default)> dfs -mkdir -p /user/hive/warehouse/dept_partition2/day=20200401/hour=12; 
hive (default)> dfs -put /opt/module/hive/datas/dept_20200402.log 
/user/hive/warehouse/dept_partition2/day=20200401/hour=12;

- 查询数据（查询不到刚刚上传的数据）

1	hive (default)> select * from dept_partition2 where day='20200401' and hour='12';

- 执行修复命令

1	hive (default)> msck repair table dept_partition2;

- 再次查询数据

1	hive (default)> select * from dept_partition2 where day='20200401' and hour='12';

2. 方式二：上传数据后添加分区- 上传数据

1
2
3

hive (default)> dfs -mkdir -p /user/hive/warehouse/dept_partition2/day=20200401/hour=13; 
hive (default)> dfs -put /opt/module/hive/datas/dept_20200403.log 
/user/hive/warehouse/dept_partition2/day=20200401/hour=13;

- 执行添加分区

1	hive (default)> alter table dept_partition2 add partition(day='20200401',hour='13');

- 查询数据

1	hive (default)> select * from dept_partition2 where day='20200401' and hour='14';

3. 方式三：创建文件夹后load数据到分区- 创建目录

1	hive (default)> dfs -mkdir -p /user/hive/warehouse/mydb.db/dept_partition2/day=20200401/hour=14;

- 上传数据

1 2	hive (default)> load data local inpath '/opt/module/hive/datas/dept_20200401.log' into table dept_partition2 partition(day='20200401',hour='14');

- 查询数据

1	hive (default)> select * from dept_partition2 where day='20200401' and hour='14';

动态分区

引言：关系型数据库中，对分区表Insert数据时候，数据库自动会根据分区字段的值，将数据插入到相应的分区中， Hive中也提供了类似的机制，即动态分区(Dynamic Partition)，只不过，使用Hive的动态分区，需要进行相应的配置。

开启动态分区参数设置

开启动态分区功能（默认true，开启）

1	hive (default)> set hive.exec.dynamic.partition=true;

设置为非严格模式（动态分区的模式，默认strict，表示必须指定至少一个分区为静态分区，nonstrict模式表示允许所有的分区字段都可以使用动态分区。）

1	hive (default)> set hive.exec.dynamic.partition.mode=nonstrict

在所有执行MR的节点上，最大一共可以创建多少个动态分区。默认1000

1	hive (default)> set hive.exec.max.dynamic.partitions=1000;

在每个执行MR的节点上，最大可以创建多少个动态分区。

1	hive (default)> set hive.exec.max.dynamic.partitions.pernode=100;

整个MR Job中，最大可以创建多少个HDFS文件。默认100000

1	hive (default)> set hive.exec.max.created.files=100000;

当有空分区生成时，是否抛出异常。一般不需要设置。默认false

1	hive (default)> set hive.error.on.empty.partition=false;

案例实操

需求：将dept表中的数据按照地区（loc字段），插入到目标表dept_partition_loc的相应分区中。

1. 创建部门地区分区表dept_partition_loc

hive (default)> 
create table dept_partition_dynamic( 
       id int, 
       name string 
) 
partitioned by (loc int) 
row format delimited fields terminated by '\t';

2. 以动态分区的方式向dept_partition_loc表中插入数据

hive (default)> insert into table dept_partition_loc partition(loc) select deptno, dname, loc 
from dept; 
FAILED: SemanticException [Error 10096]: Dynamic partition strict mode requires at least one 
static partition column. To turn this off set hive.exec.dynamic.partition.mode=nonstrict 
hive (default)> set hive.exec.dynamic.partition.mode = nonstrict; 
hive (default)> insert into table dept_partition_dynamic partition(loc) select deptno, dname, 
loc from dept;

3. 查看目标分区表的分区情况

hive (default)> show partitions dept_partition; 
OK 
partition 
loc=1700 
loc=1800 
loc=1900

分桶表

引言：

分区提供一个隔离数据和优化查询的便利方式。
不过，并非所有的数据集都可形成合理的分区。

分桶表：

对于一张表或者分区，Hive 可以进一步组织成桶，也就是更为细粒度的数据范围划分。
分桶是将数据集分解成更容易管理的若干部分的另一个技术。
分区针对的是数据的存储路径（细分文件夹）；分桶针对的是数据文件（按规则多文件放一起）。

案例实操：

创建分桶表

Hive (default)> create table stu_bucket(id int, name string) 
clustered by(id)  
into 4 buckets 
row format delimited fields terminated by '\t';

查看表结构

1 2	hive (default)> desc formatted stu_bucket; Num Buckets: 4

导入数据

导入数据到分桶表中，load 的方式将HDFS 上的数据导入到分桶表中（注意hive 版本，新版本中load 数据可以直接跑MR但是也会有点问题，老版本的Hive需要将数据传到一张表中，然后采用查询的方式导入到分桶表中）

1
2
3

// 数据仍然使用student.txt 
hive (default)> load data local inpath   '/opt/module/hive/datas/student.txt' into table 
stu_bucket;

查看创建的分桶表中是否分成4个桶

查询分桶的数据

1	hive(default)> select * from stu_bucket;

分桶规则：

Hive 的分桶采用对分桶字段的值进行哈希，
然后除以桶的个数求余的方式决定该条记录存放在哪个桶当中

分桶表操作需要注意的事项：

mapreduce.job.reduces=-1,让 Job 自行决定需要用多少个 reduce 或者将reduce 的个数设置为大于等于分桶表的桶数
从hdfs中load数据到分桶表中，避免本地文件找不到问题(跑MR任务)

insert 方式将数据导入分桶表

1 2	hive(default)> truncate table stu_bucket;（删除表内数据，不删表结构，因此只能删内表） hive(default)> insert into table stu_bucket select * from student ;

Hive查询

2024-11-11T09:56:50.000Z

基础语法及执行循序

https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Select

查询语句语法

SELECT [ALL | DISTINCT] select_expr, select_expr, ... 
FROM table_reference 
[WHERE where_condition] 
[GROUP BY col_list] 
[ORDER BY col_list] 
[CLUSTER BY col_list| [DISTRIBUTE BY col_list] [SORT BY col_list]] 
[LIMIT number]

书写次序和执行次序

顺序	书写次序	书写次序说明	执行次序	执行次序说明
1	select	查询	from	先执行表与表直接的关系
2	from	先执行表与表直接的关系	on
3	join on		join
4	where		where	过滤
5	group by	分组	group by	分组
6	having	分组后再过滤	having	分组后再过滤
7	distribute by cluster by	4个by	select	查询
8	sort by		distinct	去重
9	order by		distribute by cluster by	4个by
10	limit	限制输出的行数	sort by
11	union/union all	合并	order by
12			limit	限制输出的行数
13			union/union all	合并

基本查询（select … from …）

全表和特定列查询

数据准备

分别创建部门和员工外部表，并向表中导入数据。

在/opt/module/hive/datas目录下编辑文件dept.txt，添加如下内容。

[root@hadoop datas]$ vim dept.txt 
10 行政部 1700 
20 财务部 1800 
30 教学部 1900 
40 销售部 1700

在/opt/module/hive/datas目录下编辑文件emp.txt，添加如下内容。

[root@hadoop datas]$ vim emp.txt 
7369 张三 研发 800.00 30 
7499 李四 财务 1600.00 20 
7521 王五 行政 1250.00 10 
7566 赵六 销售 2975.00 40 
7654 侯七 研发 1250.00 30
7698 马八 研发 2850.00 30 
7782 金九 \N 2450.0 30 
7788 银十 行政 3000.00 10 
7839 小芳 销售 5000.00 40 
7844 小明 销售 1500.00 40 
7876 小李 行政 1100.00 10 
7900 小元 讲师 950.00 30 
7902 小海 行政 3000.00 10 
7934 小红明 讲师 1300.00 30

上传数据到HDFS

hive (default)> dfs -mkdir /user/hive/warehouse/dept; 
hive (default)> dfs -mkdir /user/hive/warehouse/emp; 
hive (default)> dfs -put /opt/module/hive/datas/dept.txt /user/hive/warehouse/dept; 
hive (default)> dfs -put /opt/module/hive/datas/emp.txt /user/hive/warehouse/emp;

建表语句，创建外部表

创建部门表 dept

hive(default)> create external table if not exists dept( 
deptno int,--部门编号 
dname string, --部门名称 
loc int --部门位置 
) 
row format delimited 
fields terminated by '\t';

创建员工表

hive(default)> create external table if not exists emp( 
empno int, --员工编号 
ename string, --员工姓名 
job string, --员工岗位（大数据工程师、前端工程师、java工程师） 
sal double,--员工薪资 
deptno int --部门编号 
) 
row format delimited fields terminated by '\t';

全表查询

1 2	hive (default)> select * from EMP; hive (default)> select empno,ename,job,mgr,hiredate,sal,comm,deptno from emp ;

选择特定列查询

1	hive (default)> select empno, ename from emp;

注意：SQL 语言大小写不敏感；SQL 可以写在一行或者多行；关键字不能被缩写也不能分行；各子句一般要分行写；使用缩进提高语句的可读性。

列别名

列别名：为列指定一个别名
优点：便于计算
实现：紧跟列名，也可以在列名和别名之间加入关键词‘AS’
案例实操：查询员工名字和部门名称

hive (default)> select  
          ename AS name, 
          deptno dn  
from emp;

算数运算符

运算符	描述
A+B	A和B相加
A-B	A减去B
A*B	A和B相乘
A/B	A除以B
A%B	A对B取余
A&B	A和B按位取与
A	B
A^B	A和B按位取异或
~A	A按位取反

案例实操：查询出所有员工的总收入（薪水+奖金）显示。

1	hive (default)> select ename, sal+comm income from emp;

常用函数（set hive.exec.mode.local.auto=true;本地模式）

求emp表的总行数（count）

1	hive (default)> select count(*) cnt from emp;

求emp表中工资的最大值（max）

1	hive (default)> select max(sal) max_sal from emp;

求emp表中工资的最小值（min）

1	hive (default)> select min(sal) min_sal from emp;

求emp表中工资的总和（sum）

1	hive (default)> select sum(sal) sum_sal from emp;

求emp表中工资的平均值（avg）

1	hive (default)> select avg(sal) avg_sal from emp;

LIMIT 语句(limit 语句)

一般的查询会返回多行数据，在成产环境中，通常使用LIMIT子句用于限制返回的行数。

1 2	hive (default)> select ename, sal from emp limit 5; hive (default)> select ename, sal from emp limit 2,3;

WHERE 语句(where 语句)

使用WHERE子句，将不满足条件的行过滤掉
WHERE子句紧随FROM子句
案例实操：查询出薪水大于1000的所有员工

1	hive (default)> select * from emp where sal > 1000;

注意：where子句中不能使用字段别名。

比较运算符（Between/In/In Null）

下面表中描述了谓词操作符，这些操作符同样可以用于JOIN…ON和HAVING语句中。

（null与其他值比较或者运算得到的结果也是null）

操作符	支持的数据的类型	描述
A=B	基本数据类型	如果A等于B则返回TRUE，反之返回FALSE
A<=>B	基本数据类型	如果A和B都为NULL，则返回TRUE，如果一边为NULL，返回False
A<>B, A!=B	基本数据类型	A或者B为NULL则返回NULL；如果A不等于B，则返回TRUE，反之返回FALSE
A	基本数据类型	A或者B为NULL，则返回NULL；如果A小于B，则返回TRUE，反之返回FALSE
A$ \leq $B	基本数据类型	A或者B为NULL，则返回NULL；如果A小于等于B，则返回TRUE，反之返回FALSE
A>B	基本数据类型	A或者B为NULL，则返回NULL；如果A大于B，则返回TRUE，反之返回FALSE
A$ \geq $B	基本数据类型	A或者B为NULL，则返回NULL；如果A大于等于B，则返回TRUE，反之返回FALSE
A [NOT] BETWEEN B AND C	基本数据类型	如果A，B或者C任一为NULL，则结果为NULL。如果A的值大于等于B而且小于或等于C，则结果为TRUE，反之为FALSE。如果使用NOT关键字则可达到相反的效果。
A IS NULL	所有数据类型	如果A等于NULL，则返回TRUE，反之返回FALSE
A IS NOT NULL	所有数据类型	如果A不等于NULL，则返回TRUE，反之返回FALSE
IN(数值1, 数值2)	所有数据类型	使用 IN运算显示列表中的值
A [NOT] LIKE B	STRING类型	B是一个SQL下的简单正则表达式，也叫通配符模式，如果A与其匹配的话，返回TRUE；反之返回FALSE。 B的表达式说明如下： ‘x%’表示A必须以字母‘x’开头，（%代表任意个数字符） ‘%x’表示A必须以字母’x’结尾，（_代表任一一个字符） ‘%x%’表示A包含有字母’x’,可以位于开头，结尾或者字符串中间。如果使用NOT关键字则可达到相反的效果。（不支持正则）
A RLIKE B	STRING类型	B是基于java的正则表达式，如果A与其匹配，则返回TRUE；反之返回FALSE。匹配使用的是JDK中的正则表达式接口实现的，因为正则也依据其中的规则。例如，正则表达式必须和整个字符串A相匹配，而不是只需与其子字符串匹配。

案例实操：

1. 查询出薪水等于5000的所有员工

hive (default)> select * from emp where sal =5000; 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7839    KING    PRESIDENT       NULL    1981-11-17      5000.0  NULL    10

2. 查询工资在500到1000的员工信息

hive (default)> select * from emp where sal between 800 and 1100; 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7369    SMITH   CLERK   7902    1980-12-17      800.0   NULL    20 
7876    ADAMS   CLERK   7788    1987-5-23       1100.0  NULL    20 
7900    JAMES   CLERK   7698    1981-12-3       950.0   NULL    30

3.  查询job为空的所有员工信息

hive (default)> select * from emp where job is null; 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7369    SMITH   CLERK   7902    1980-12-17      800.0   NULL    20 
7566    JONES   MANAGER 7839    1981-4-2        2975.0  NULL    20 
7698    BLAKE   MANAGER 7839    1981-5-1        2850.0  NULL    30 
……

4. 查询工资是1500或5000的员工信息

hive (default)> select * from emp where sal IN (1500, 5000); 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7839    KING    PRESIDENT       NULL    1981-11-17      5000.0  NULL    10 
7844    TURNER  SALESMAN        7698    1981-9-8        1500.0  0.0     30

LIKE和RLIKE(like和rlike)

like关键词：使用LIKE运算选择类似的值
选择条件可以包含字符或数字：

% $ \rightarrow $ 代表零个或多个字符(任意个字符)。

_ $ \rightarrow $ 代表一个字符。

RLIKE关键字：RLIKE子句是Hive中这个功能的一个扩展，其可以通过Java的正则表达式这个更强大的语言来指定匹配条件。

$x $ \rightarrow $ 代表以x结尾

^x $ \rightarrow $ 代表以x开头

.* $ \rightarrow $ 任意数量字符

. $ \rightarrow $ 一个任意字符

* $ \rightarrow $ 上一个字符可以无限次出现或者不出现

案例实操
1. 查找名字以“小”开头的员工信息

1 2	hive (default)> select * from emp where ename LIKE '小%'; hive (default)> select * from emp where ename RLIKE '^小';

2. 查找名字以“明”结尾的员工信息

1 2	hive (default)> select * from emp where ename LIKE '%明'; hive (default)> select * from emp where ename RLIKE '明$';

3. 查找名字中带有“明”的员工信息

1 2	hive (default)> select * from emp where ename LIKE '%明%'; hive (default)> select * from emp where ename RLIKE '[明]';

逻辑运算符（AND/OR/NOT）

操作符	含义
AND	逻辑并
OR	逻辑或
NOT	逻辑否

案例操作：

1. 查询薪水大于1000，部门是30

hive (default)> select * from emp where sal>1000 and deptno=30; 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7499    ALLEN   SALESMAN        7698    1981-2-20       1600.0  300.0   30 
7521    WARD    SALESMAN        7698    1981-2-22       1250.0  500.0   30 
7654    MARTIN  SALESMAN        7698    1981-9-28       1250.0  1400.0  30 
7698    BLAKE   MANAGER 7839    1981-5-1        2850.0  NULL    30 
7844    TURNER  SALESMAN        7698    1981-9-8        1500.0  0.0     30

2. 查询薪水大于1000，或者部门是30

hive (default)> select * from emp where sal>1000 or deptno=30; 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7499    ALLEN   SALESMAN        7698    1981-2-20       1600.0  300.0   30 
7521    WARD    SALESMAN        7698    1981-2-22       1250.0  500.0   30 
7566    JONES   MANAGER 7839    1981-4-2        2975.0  NULL    20 
7654    MARTIN  SALESMAN        7698    1981-9-28       1250.0  1400.0  30 
7698    BLAKE   MANAGER 7839    1981-5-1        2850.0  NULL    30 
7782    CLARK   MANAGER 7839    1981-6-9        2450.0  NULL    10 
7788    SCOTT   ANALYST 7566    1987-4-19       3000.0  NULL    20 
7839    KING    PRESIDENT       NULL    1981-11-17      5000.0  NULL    10 
7844    TURNER  SALESMAN        7698    1981-9-8        1500.0  0.0     30 
7876    ADAMS   CLERK   7788    1987-5-23       1100.0  NULL    20 
7900    JAMES   CLERK   7698    1981-12-3       950.0   NULL    30 
7902    FORD    ANALYST 7566    1981-12-3       3000.0  NULL    20 
7934    MILLER  CLERK   7782    1982-1-23       1300.0  NULL    10

3. 查询除了20部门和30部门以外的员工信息

hive (default)> select * from emp where deptno not IN(30, 20); 
OK 
emp.empno       emp.ename       emp.job emp.mgr emp.hiredate    emp.sal emp.comm        
emp.deptno 
7782    CLARK   MANAGER 7839    1981-6-9        2450.0  NULL    10 
7839    KING    PRESIDENT       NULL    1981-11-17      5000.0  NULL    10 
7934    MILLER  CLERK   7782    1982-1-23       1300.0  NULL    10

分组

GROUP BY 语句（group by 语句）

GROUP BY语句通常会和聚合函数一起使用，按照一个或者多个列队结果进行分组，然后对每个组执行聚合操作。

案例实操：

1. 计算emp表每个部门的平均工资

hive (default)> select t.deptno, avg(t.sal) avg_sal from emp t group by t.deptno; 
OK 
t.deptno        avg_sal 
10      2916.6666666666665 
20      2175.0 
30      1566.6666666666667

2. 计算emp每个部门中每个岗位的最高薪水

hive (default)> select t.deptno, t.job, max(t.sal) max_sal from emp t group by t.deptno, t.job; 
OK 
t.deptno        t.job   max_sal 
20      ANALYST 3000.0 
10      CLERK   1300.0 
20      CLERK   1100.0 
30      CLERK   950.0 
10      MANAGER 2450.0 
20      MANAGER 2975.0 
30      MANAGER 2850.0 
10      PRESIDENT       5000.0 
30      SALESMAN        1600.0

HAVING 语句（having 语句）

having与where不同点：

where后面不能写聚合函数，而having后面可以使用聚合函数。

having只用于group by分组统计语句。

案例实操：

1. 求每个部门的平均工资

hive (default)> select deptno, avg(sal) from emp group by deptno; 
OK 
t.deptno        avg_sal 
10      2916.6666666666665 
20      2175.0 
30      1566.6666666666667

2. 求每个部门的平均薪水大于2000的部门

hive (default)> select deptno, avg(sal) avg_sal from emp group by deptno having avg_sal > 2000; 
OK 
deptno  avg_sal 
10      2916.6666666666665 
20      2175.0

JOIN 语句

具体查看：Visual Representation of SQL Joins- CodeProject

数据准备：

（set mapreduce.job.reduces;

mapreduce.job.reduces=-1）默认是按照数据量来分配

为了体现学习上述所种join方式，现在需要为emp表和dept表添加特有数据

为emp表添加一条数据，员工编号1001，姓名fanfan等信息，但是部门编号设为50

1 2	hive(defult)> insert into table emp values(1001, 'fanfan', 'sing',7839, '2021-08 16',9000000,500000,50);

等值 JOIN

Hive支持通常的SQL JOIN语句。

案例实操：根据dept表和emp表中的deptno相等，查询empno、deptno、ename和dname；

hive(default)> select 
empno, 
dept.deptno, 
ename, 
dname 
from emp 
join dept on emp.deptno=dept.deptno;

表的别名 AS

使用表的别名的好处

使用别名可以简化查询。
使用表的别名可以区分字段的来源。

案例实操：合并员工表和部门表

hive (default)> select  
e.empno, 
d.deptno, 
e.ename, 
d.dname 
from emp e 
join dept d on e.deptno=d.deptno;

内连接 INNER JOIN

内连接：只有进行连接的两个表中都存在与连接条件相匹配的数据才会被保留下来。

案例实操：通过emp表和dept表查询员工编号、员工姓名、部门编号、部门名称。

hive (default)> select 
e.empno, 
e.ename, 
e.deptno, 
d.deptno, 
d.dname 
from emp e 
join dept d on e.deptno=d.deptno;

左外连接 LEFT JOIN

左外连接：JOIN操作符左边表中符合join子句的所有记录将会被返回。

案例实操：通过emp表和dept表查询员工编号、员工姓名、部门编号、部门名称。

hive(default)> select 
e.empno, 
e.ename, 
e.deptno, 
d.deptno, 
d.dname 
from emp e 
left join dept d on e.deptno=d.deptno; 
ok 
e.empno  e.ename   e.deptno  d.deptno  d.dname 
1001      fanfan    50          NULL       NULL 
……

右外连接 RIGHT JOIN

右外连接：JOIN操作符右边表中符合join子句的所有记录将会被返回。

案例实操：通过emp表和dept表查询员工编号、员工姓名、部门编号、部门名称。

hive (default)> select 
e.empno, 
e.ename, 
e.deptno, 
d.deptno, 
d.dname 
from emp e 
right join dept d on e.deptno=d.deptno; 
OK 
e.empno  e.ename   e.deptno  d.deptno  d.dname 
NULL      NULL       NULL      40         OPERATIONS

满外连接 OUTER JOIN

满外连接：将会返回所有表中符合WHERE语句条件的所有记录。

案例实操：通过emp表和dept表查询员工编号、员工姓名、部门编号、部门名称。

hive (default)> select 
           e.empno, 
           e.ename, 
           e.deptno, 
           d.deptno, 
           d.dname 
           from emp e 
full join dept d on e.deptno=d.deptno; 
Ok 
e.empno  e.ename   e.deptno  d.deptno  d.dname 
NULL      NULL       NULL      40         OPERATIONS 
1001      fanfan    50          NULL       NULL 
……

多表连接 OUTER EXCLUDING JOIN

注意：连接 n个表，至少需要n-1个连接条件。例如：连接三个表，至少需要两个连接条件。

数据准备：在/opt/module/hive/datas/ 下创建文件location.txt，内容如下：

[root@hadoop datas]$ vim location.txt 
1700 北京 
1800 上海 
1900 深圳

创建表location

hive(default)> create table if not exists location( 
loc int, --部门位置id 
loc_name string --部门位置 
) 
row format delimited fields terminated by '\t';

向location表中导入数据

1	hive (default)> load data local inpath '/opt/module/hive/datas/location.txt' into table location;

多表连接实操：查询每个员工姓名、部门名称及部门所在地。

hive (default)> select 
           e.ename, 
           d.dname, 
           l.loc_name 
from emp e 
join dept d on e.deptno=d.deptno 
join location l on d.loc=l.loc;

join操作转换成MR：

大多数情况下，Hive会对每对JOIN连接对象启动一个MapReduce任务。
本例中会首先启动一个MapReduce job对表e和表d进行连接操作，
然后会再启动一个MapReduce job将第一个MapReduce job的输出和表l进行连接操作。

注意：为什么不是表d和表l先进行连接操作呢？这是因为Hive总是按照从左到右的顺序执行的。

笛卡尔积

笛卡尔积会在下面条件下产生：

省略连接条件

连接条件无效

所有表中的所有行互相连接

案例实操：hive (default)> select empno, dname from emp, dept;

排序

全局排序 ORDER BY

order by:全局排序，只有一个Reducer
顺序：ASC(ascend)：升序（默认升序）；DESC(descend)：降序
位置：ORDER BY子句在SELECT语句的结尾
案例实操：

查询员工信息按工资升序排列

1	hive (default)> select * from emp order by sal;

查询员工信息按工资降序排列

1	hive (default)> select * from emp order by sal desc;

按照员工薪水的2倍排序

1	hive (default)> select ename, sal*2 twosal from emp order by twosal;

按照部门和工资升序排序

1	hive (default)> select ename, deptno, sal from emp order by deptno, sal ;

使用order by 对数据排序时只有一个reduce，面对海量数据排序时，一个reduce 效率太低，并且大多数场景下，并不需要全局排序。

每个REDUCE内部排序（SORT BY）

sort by：在每个 Reducer 内部进行排序，对全局结果集来说不是有序。sort by 为每个 reducer 产生一个排序文件，每个Reducer内部进行排序，对全局结果来说不是排序。
通过命令设置reduce个数（Hive默认会根据数据量来设置reduce的个数，这里手动设置reduce个数）

1 2	hive (default)> set mapreduce.job.reduces=3; hive (default)> set mapreduce.job.reduces;

案例实操：

根据部门编号降序查看员工信息

1	hive (default)> select * from emp sort by deptno desc;

将查询结果导入到文件中（按照部门编号降序排序）

hive (default)> insert overwrite local directory '/opt/module/hive/datas/sortby-result' 
row format delimited fields terminated by '\t ' 
select *  
from emp  
sort by deptno desc;

分区（DISTRIBUTE BY）

distribute by：在有些情况下，我们需要控制某个特定行应该到哪个reducer，通常时为了进行后续的聚集操作。 distribute by 可以实现。distribute by 类似 MR 中 partition（自定义分区），进行分区，结合 sort by 使用。对于distribute by 进行测试，一定要分配多reduce进行处理，否则无法看到distribute by的效果。

案例实操：先按照部门编号分区，再按照员工薪水降序排序。

hive (default)> set mapreduce.job.reduces=3; 
hive (default)> insert overwrite local directory '/opt/module/hive/datas/distribute-result' 
row format delimited fields terminated by '\t' 
select 
ename, 
empno, 
deptno, 
sal  
from emp  
distribute by deptno 
sort by sal desc;

注意：

distribute by 的分区规则是根据分区字段的hash 码与reduce 的个数进行模除后，余数相同的分到一起。
Hive 要求DISTRIBUTE BY 语句要写在SORT BY 语句之前。
测试完毕后，记得将mapreduce.job.reduces 的值恢复到-1，否则下面的分区和分桶测试就会报错。

CLUSTER BY

cluster by：

当distribute by 和sort by 字段相同时，可以使用cluster by方式。
cluster by 除了具有distribute by 的功能外还兼具sort by的功能。
但是排序只能是升序排序，不能指定排序规则为ASC或者DESC。

案例实操：查询emp表中的员工姓名、员工编号、部门编号、薪资，并按照部门编号分区排序。以下两种写法等价

1 2	hive (default)> select ename,empno,deptno,sal from emp cluster by deptno; hive (default)> select ename,empno,deptno,sal from emp distribute by deptno sort by deptno;

注意：按照部门编号分区，不一定就是固定死的数值，可以是20号和30号部门分到一个分区里面。

HCIA-821模拟卷

2024-11-07T03:38:27.000Z

最近忙着实习，忙着考试，忙着好多好多，想闲下来。在网上找题库，找不齐。浅浅的上传一个模拟卷。

（HCIA-821模拟卷）

1、网络管理员给网络中的某台主机分配的IPv4地址为192.168.1.1/28、则这个主机所在的网络还可以增加多少台主机?（）

A、12 B、15 C、13 D、14

试题答案：C

试题解析：192.168.1.1/28对应的2进制表示为11000000.10101000.00000001.0000 0000/28。前28位固定为网络位，最后4位为主机位。网络位固定不变，变化主机位！可以看到主机位可以从0000变化到1111，共16种变化！除去主机位全0（代表网络地址）、全1（代表广播地址）的情况，剩下14个合法的IP地址，范围是192.168.1.1~192.168.1.14。故选C。

2、下面哪个OSPF版本适用于IPv6?（）

A、OSPFv1 B、OSPFv2 C、OSPFv3 D、OSPFv4

试题答案：C

试题解析：OSPF协议是为IP协议提供路由功能的路由协议。OSPFv2（OSPF版本2）是支持IPv4的路由协议，为了让OSPF协议支持IPv6，技术人员开发了OSPFv3（OSPF版本3），OSPFv3由RFC2740定义。故选C。

3、VRP操作平台、以下哪条命令可以只查看静态路由?（）

A、display ip routing-table statistics B、display ip routing-table verbose

C、display ip routing-table D、display ip routing-table protocol static

试题答案：D

试题解析：display ip routing-table protocol static，该命令是只查看路由表中通过静态配置方式获得路由条目。故选D。

4、路由器工作在OSI参考模型的哪一层?（）

A、数据链路层 B、传输层 C、应用层 D、网络层

试题答案：D

试题解析：路由器工作在OSI七层模型的第三层网络层，路由器使用IP地址进行寻址，实现源IP到目标IP的端到端的无连接数据报服务。故选D。

5、如果应用层协议为TeInet，那么IPv4首部中Protocol字段取值为?（）

A、23 B、17 C、6 D、67

试题答案：C

试题解析：ipv4报文头部中的protocol字段的作用为描述上层协议，数值为6的时候代表上层使用tcp协议。而telnet是基于tcp协议工作的，因此答案选C。

6、OSPF协议使用哪种报文对接收到的LSU报文进行确认?（）

A、LSU B、LSR C、LSACK D、LSA

试题答案：C

试题解析：LSU报文用来向对端Router发送其所需要的LSA或者泛洪自己更新的LSA，内容是多条LSA（全部内容）的集和。LSR报文用于请求相邻路由器链路状态数据库中的一部分数据。LSAck报文是路由器在收到对端发来的LSU报文后所发出的确认应答报文。LSA并不是报文，其描述的为ospf的拓扑和路由信息，由lsu进行承载。故选C。

7、主机使用以下哪个IPv4地址不能直接访问Internet? （）

A、100.1.1.1 B、50.1.1.1 C、10.1.1.1 D、200.1.1.1

试题答案：C

试题解析：10.1.1.1因为这是一个私网地址。私网地址是无法直接访问互联网的。需要做NAT转换才行。故选C。

8、在路由表中存在到达同一个目的网络的多个路由条目，这些路由称之为?（）

A、次优路由 B、多径路由 C、等价路由 D、默认路由

试题答案：C

试题解析：在一台路由设备上，如果有多条路由去往同一目的网络并且他们的开销COST一样我们称之为等价路由。答案A次优路由是指两条路由的COST不相同，答案B和D为干扰项。

9、以下关于直连路由说法正确的是?（）

A、直连路由优先级低于动态路由 B、直连路由优先级低于静态路由

C、直连路由优先级最高 D、直连路由需要管理员手工配置目的网络和下一跳地址

试题答案：C

试题解析：直连路由默认优先级为0，优先级最高，所以AB是错误的。直连路由为路由器自动生成所以D错误，故选C。

10、在华为路由器上，缺省情况下OSPF协议内部路由优先级的数值为?（）

A、20 B、10 C、30 D、0

试题答案：B

试题解析：缺省情况下OSPF协议内部路由优先级的数值为10。故选B。

11、OSPF协议使用哪种报文发现和维护邻居关系?（）

A、DD B、LSR C、LSU D、HELLO

试题答案：D

试题解析：当OSPF中的两个路由器初始化连接时要交换数据库描述(DD)报文。OSPF报文的第三种类型为链路-状态请求（LSR）报文。链路-状态更新(LSU)报文用于把LSA发送给它的相邻节点。OSPF使用hello报文建立和维护相邻站点之间的邻居关系。

故选D。

12、以下关于直连路由说法正确的是?（）

A、直连路由需要管理员手工配置目的网络和下—跳地址

B、直连路由优先级低于静态路由

C、直连路由优先级低于动态路由

D、直连路由优先级最高

试题答案：D

试题解析：直连路由默认优先级为0。优先级最高，故选D。

13、下列关于华为设备中静态路由的说法错误的是?（）

A、静态路由的开销值（Cost）不可以被修改

B、静态路由优先级的缺省值为60

C、静态路由优先级值的范围为1-255

D、静态路由的优先级为0时，则该路由一定会被优选

试题答案：D

试题解析：静态路由没有开销说法故A是对的。静态路由的默认优先级是60故B是对的。路由优先级的范围是0-255，静态路由的范围是1-255故C是对的。D选项与C选项互斥。

14、如下图所示的网络，所有路由器运行OSPF协议，链路上方为Cost值的大小，则RTA到达网络10.0.0.0/8的路径为?（）

A、A-B-D B、RTA无法到达10.0.0.0/8 C、A-C-D D、A-D

试题答案：C

试题解析：Cost值的计算是沿目的地途中所有转发数据的接口的cost值的总和、越小越优。

15、下列配置默认路由的命令中正确的是？（）

A、[Huawei-Seria10]ip route-statiC 0.0.0.0. 0.0.0.0 0.0.0.0

B、[Huawei]ip route-statiC 0.0.0.0 0.0.0.0 192.168.1.1

C、[Huawei]ip route-statiC 0.0.0.0 0.0.0.0 0.0.0.0

D、[Huawei]ip route-statiC 0.0.0.0 255.255.255.255 192.168.1.1

试题答案：B

试题解析：根据默认路由的配置格式：ip route-stacic 0.0.0.0 0.0.0.0 下一跳IP地址（应为单播地址）。

16、主机的IPv4地址为200.200.200.201/30、拥有下列哪个IPv4地址的主机和其通信不需要经过路由器转发？（）

A、200.200.200.202 B、200.200.200.200

C、200.200.200.203 D、200.200.200.1

试题答案：A

试题解析：同一网段不需要路由可以通信，200.200.200.201/30 网段内只有4个主机位，200.200.200.200-200.200.200.203，去掉一个广播地址200.200.200.203，去掉一个网络地址200.200.200.200，只有200.200.200.201与200.202可用.所以本题选A。

17、OSPF协议的HELLO报文中不包含以下哪个字段？（）

A、Neighbor B、Network Mask

C、HelloInterval D、Sysname

试题答案：D

试题解析：HELLO报文包含Network Mask、HELLO Intval、options、Router priority、router dead interval、designated router、Backup designated router、active neighbor等。本题不包含Sysname，选D。

18、管理员要在路由器的G0/0/0接口上配IP地址，那么使用下面哪个地址才是正确的？（）

A、192.168.10.112/30 B、237.6.1.2/24

C、127.3.1.4/28 D、145.4.2.55/26

试题答案：D

试题解析：子网掩码为/30时，192.168.10.112是一个广播地址，选项A错误。237.6.1.2/24是组播地址，B错误。127.3.1.4/28属于本地回环地址，C错误。所以本题选D。

19、如果一个网络的广播地址为172.16.1.255，那么它的网络地址可能是？（）

A、172.16.1.128 B、172.16.2.0

C、172.16.1.1 D、172.86.1.253

试题答案：A

试题解析：广播地址为172.16.1.255，它的网络地址不可能到2.0网段，所以B错误。当子网掩码为24位时，网络地址为172.16.1.0.选项C错误。子网掩码为31位时，网络地址为172.86.1.254，子网掩码为30位时，网络地址为172.86.1.252，所以选项D错误。当子网掩码为25位时，网络地址为172.16.1.128。所以本题选A。

20、OSPF报文类型有多少种？（）

A、2 B、4 C、5 D、3

试题答案：C

试题解析：OSPF包含Hello、DD、LSR、LSU、LSACK五种报文。所以本题选C。

21、当以IPv4协议作为网络层协议时，网络层首部不包含哪个字段?（）

A、Source IPv4 Address B、TTL

C、Destination IPv4 Address D、Sequence Number

试题答案：D

试题解析：Sequence Number 是TCP序列号，其他都是网络层首部的内容。本题选D 。

22、某公司申请到一个C类地址段，需要平均分配给8个子公司，最大的一个子公司有14台计算机，不同的子公司必须在不同的网段中，则子网掩码应该设计为？（）

A、255.255.255.240 B、255.255.255.128

C、255.255.255.192 D、255.255.255.0

试题答案：A

试题解析：因为最大的一个子公司有14台主机，所以每个网段需满足至少16个主机位（要去掉一个网络地址、一个广播地址），所以本题选A 255.255.255.240。选项B只有两个网段，选项C只有4个网段，选项D只有一个网段。

23、下列哪个属性不能作为衡量Cost的参数？（）

A、带宽 B、Sysname C、时延 D、跳数

试题答案：B

试题解析：动态路由衡量cost有度量值、跳数、带宽、时延、负载等等。sysname 系统名不能作为衡量Cost的参数，本题选B。

24、缺省情况下，广播网络上ospf协议RouterDeadInterval是？（）

A、10s B、40s C、30s D、20s

试题答案：B

试题解析：ospf的 RouterDeadInterval为四倍hello time时间，hello time 周期默认为10s，所以 RouterDeadInterval 默认为40s ，当设备40s内没有收到邻居发送的 hello报文，则认为邻居失效，因此答案选B 。

25、缺省情况下，广播网络上OSPF协议HELLO报文发送的周期为？（）

A、10s B、40s C、30s D、20s

试题答案：A

试题解析：ospf的hello报文发送周期为10s一次，用于建立以及维护邻居关系。因此答案选A 。

26、下列哪一个IPv4地址是A类地址？（）

A、192.168.1.1 B、100.1.1.1 C、127.0.0.1 D、172.16.1.1

试题答案：B

试题解析：A类地址的取值范围为0.0.0.0-126.255.255.255，127.0.0.0-127.255.255.255 属于特殊地址，用于测试网卡以及TCP/IP协议栈是否正常的，B类地址的取值范围为128.0.0.0-191.255.255.255，C类地址的取值范围为192.0.0.0-223.255.255.255 ，因此答案选B 。

27、已知某台路由器的路由表中有如图两个表项，如果该路由器要转发目的地址为9.1.4.5的报文，则下列说法中正确的是？（）

A、选择第二项作为最优匹配项，因为RIP协议的代价值较小

B、选择第二项作为最优匹配项，因为该路由相对于目的地为9.1.4.5来说，是更精确的匹配

C、选择第二项作为最优匹配项，因为Ethemet0的速度比serial0的速度更快

D、选择第一项作为最优匹配项，因为ospf协议的优先级值较高

试题答案：B

试题解析：从图片可以看出，目的ip为9.1.4.5的数据报可以匹配9.0.0.0/8、9.1.0.0/16两条路由条目，9.0.0.0/8是通过ospf协议学习到的，路由优先级为10 开销值为50 ，9.1.0.0/16是通过isis学习到的，路由优先级为15，开销值为100，由于路由的优先原则，先比较路由条目的子网掩码，越长越优先，再比较路由条目的优先级和开销值，9.1.0.0/16比9.0.0.0/8掩码长度更长，相对而言更加精确，因此会选择9.1.0.0/16这条路由条目进行转发，而不会再比较优先级以及开销值，所以答案选B 。

28、下面关于IP报文头部中TTL字段的说法正确的是？（）

A、TTL定义了源主机可以发送数据包的时间间隔

B、TTL定义了源主机可以发送数据包的数量

C、IP报文每经过一台路由器时,其TTL值会被减1

D、IP报文每经过一台路由器时,其TTL值会1被加1

试题答案：C

试题解析：TTL值的主要作用是设置数据包可以经过的路由器数量，每经过一台路由器是，TTL值会被减1 ，当数据包的TTL数值为0时，将会被丢弃，其作用是当网络中出现环路的时候，起到破环的作用。因此答案选C 。

29、一个网段150.25.0.0的子网掩码是255.255.224.0，那么该网段中的有效的主机地址是？（）。

A、150.25.2.24 B、150.25.0.0 C、150.25.1.255 D、150.15.3.30

试题答案：A;C

试题解析：Ip地址为150.25.0.0 子网掩码为255.255.224.0（网络位19，主机位13位）。网络地址为：150.25.0.0。广播地址为：150.25.31.255。主机地址为：150.25.0.1-150.25.31.254。答案B为网络地址，答案D为150.15.3.30不在150.25.0.0。

30、ospf协议在网络层对应的协议号是多少？（）

A、89 B、6 C、0 D、1

试题答案：A

试题解析：ospf用ip报文直接封装协议报文，其协议号为89.因此答案选A。

31、OSPF协议的Hello报文中不包含以下哪个字段？（）

A、Network Mask B、sysname C、HelloInterval D、Neighbor

试题答案：B

试题解析：ospf的hello报文中包含network mask（子网掩码）、hellointerval（hello报文间隔）、routedeadinterval（死亡时间）、neighbor（邻居列表）。并不包含sysname ，ospf之间来代表身份的是使用设备的route id而不是sysname ，所以答案选B。

32、下列配置默认路由的命令中正确的是？（）

A、[huawei-serial0]ip route-statiC 0.0.0.0 0.0.0.0 0.0.0.0

B、[huawei] ip route-statiC 0.0.0.0 255 255.255 255 192. 168.1.1

C、[huawei] ip route-statiC 0.0.0.0 0.0.0.0 192.168.1.1

D、[huawei] ip route-statiC 0.0.0.0 0.0.0.0 0.0.0.0

试题答案：C

试题解析：默认路由的目标网段为0.0.0.0 0.0.0.0 ，表示一个未知网段，下一跳地址一定是一个有效的ip地址，而A D两个答案的0.0.0.0 明显不符合要求，B的目标网段写法错误，因此答案选C 。

33、192.168.1.127/25代表的是什么地址？

A、广播 B、组播 C、网络 D、主机

试题答案：A

试题解析：由题目提供信息可看出，192.168.1.127/25 此ip网段的网络位为25位，主机位为7位，此网段最小的ip地址就是将主机位的比特位全取0，127化成二进制为 0111 1111 ，主机位全取0 （0000 0000），那么网络地址就是192.168.1.0，当主机位全取1（0111 1111）的时候，此地址为此网段的广播地址，算出来是192.168.1.127 ，因此192.168.1.127是本网段的广播地址。答案选A。

34、ip route-static 10.0.12.0 255.255.255.0 192.168.1.1关于此命令描述正确的是？（）

A、此命令配置了一条到达10.0. 12.0网络的路由

B、该路由的优先级为100

C、如果路由器通过其他协议学习到和此路由相同目的网络的路由器，路由器将会优先选择此路由

D、此命令配置了一条到达192. 168.1.1网络的路由

试题答案：A

试题解析：ip route-static10.0.12.0 255.255.255.0 192.168.1.1，此命令配置了一条目标网段为10.0.12.0/24 ，下一跳为192.168.1.1的静态路由，默认优先级为60，如果通过其他协议学习到相同的目的网络的路由条目，路由器会跟据优先级进行路由的优选，优先级越小越优先。因此答案选A。

35、如下图所示的网络，当OSPF邻居状态稳定后，RouterB和RouterC的邻居状态为?（）

A、Attempt B、2-way C、Full D、Down

试题答案：B

试题解析：路由器B和C的优先级都为0，只能成为DR-other，DR-other之间的邻居关系为two-way,故选B。

36、如下图所示，下列说法正确是？（）

A、主机A可以ping通主机B

B、只有把主机A和主机B的掩码设置为一致，主机A和主机B才能通信

C、主机A和主机B的广播地址相同

D、主机A和主机B的IP地址掩码不同，所以主机A和主机B不能通信

试题答案：D

试题解析：由题目可以得知，host A的ip为10.1.12.1/30 ，属于10.1.12.0/30网段,host B的ip为10.0.12.5/24，属于10.0.12.0/24网段，双方主机不属于一个网段，虽然host B会有10.1.12.1的路由信息，但是host B没有10.0.12.5的路由信息，因此会导致hostB能够发送报文给hostA ，但是host A无法回包，导致不能通信。因此答案选D。

37、VRP操作平台、以下哪条命令可以只查看静态路由？（）

A、display ip routing-table protocol static

B、display ip routing-table

C、display ip routing-table verbose

D、display ip routing-table statistics

试题答案：A

试题解析：在VRP平台中查看路由条目的命令是display ip routing-table，如果想单独查看不同的路由协议产生的路由条目，可以使用 display ip routing-table protocl (路由类型)，如查看静态路由就使用display ip routing-table protocol static。查看ospf产生的路由条目就使用 display ip routing-table protocol ospf 。因此答案选A。

38、如下图所示的网络，所有路由器运行OSPF协议，链路开销值如图，则RTA路由表中到达网络10.0.0.0/8的路由条目的cost值是多少？（）

A、70 B、100 C、20 D、60

试题答案：D

试题解析：通过题目拓扑可以得知，RTA分别可以从RTB、RTC、RTD学习到10.0.0.0/8 的路由条目，开销值分别是70、60、100,由于都是通过ospf学习到的路由相同网段的条目，此时会比较路由条目的开销值，越小越优先。因此答案选D。

39、某台运行了OSPF的设备，在没有指定router-id是多少的时候，会使用以下哪个接口的IP地址作为自己OSPF进程的router-id ?（）

A、Ethernet0/0/0 10.0.12.1

B、Ethernet0/0/1 10.0.21.1

C、Loopback0 1.1.1.1

D、Loopback1 2.2.2.2

试题答案：D

试题解析：如果OSPF 路由器未使用 OSPF router-id 命令进行配置，如果配置了环回口，则以环回口地址最大的ip作为router id，如果未配置环回口，则比较接口ip地址，越大越优先，所以选择选项"D"。

40、路由表不包含以下哪项参数?（）

A、目的地址/掩码 B、Cost开销 C、MAC地址 D、next-hop下一跳

试题答案：C

试题解析：因为路由表包含的参数只有网络地址（Network Destination）、网络掩码（Netmask）、网关（Gateway，又称为下一跳服务器）、接口（Interface）、跃点数（Metric），而MAC地址不属于路由器包含的参数。所以选择选项"C"。

41、接口通过数据帧的哪个信息判断进行二层转发或三层转发？（）

A、源IP B、源MAC C、目的端口 D、目的MAC

试题答案：D

试题解析：当接口收到一个数据帧的时候，如果目的mac地址为自己的mac地址，说明此数据需要交给本设备处理，则进行三层转发，如果目的mac地址不是自己的mac地址，则通过查找mac地址表进行二层转发。所以此题答案选D 。

42、以下关于交换机的描述，说法错误的是？（）

A、交换机一般作为网络的出口设备

B、交换机一般工作在数据链路层

C、交换机能够完成数据帧的交换工作

D、交换机可以为终端设备（PC/服务器）提供网络接入服务

试题答案：A

试题解析：交换设备分为二层交换机和三层交换机，交换设备一般工作在数据链路层，并且能够通过mac地址完成数据帧的交换工作，二层交换一般为终端设备提供接入服务，网络出口设备通常会选择路由器实现不同网络之间的选路及转发工作。

43、STP协议中端口处于哪个工作状态时可以不经过其它状态转为Forwarding状态？（）

A、BIocking B、Learning C、Listening D、Disabled

试题答案：B

试题解析：在Learning状态下经过一段时间的延迟，将自动进入Forwarding状态，本题选B。

44、命令port trunk allow-pass vlan all有什么作用？（）

A、如果为相连的远端设备配置了port default vlan3命令，则两台设备间VLAN3无法互通

B、该端口上允许所有VLAN的数据帧通过

C、相连的对端设备可以动态确定允许哪些VLAN ID .通过

D、与该端口相连的对端端口必须同时配置port trunk permit vlan all确认

试题答案：B

试题解析：port trunk allow-pass vlan all 作为vlan trunk的配置命令，可以放行所有VLAN通过，所以本题选B。

45、关于传输层协议说法正确的有（）。

A、UDP适合传输对时延敏感的流量，并且可以依据报文首部中的序列号字段进行重组

B、知名端口号范围为0-1023

C、UDP使用SYN和ACK标志位来请求建立连接和确认建立连接

D、TCP连接的建立是个三次握手的过程，而TCP连接的终止则要经过四次握手

试题答案：B;D

试题解析：UDP适合传输对时延敏感的流量，依据报文首部中的序列号字段进行重组的是TCP。A错误。TCP使用SYN和ACK标志位来请求建立连接和确认建立连接.C错误。本题选B、D

46、以下哪些与封装和解封装的目的有关？（）

A、封装和解封装是实现不同协议功能的重要步骤

B、不同网络之间的互通

C、缩短报文的长度

D、封装和解封装可以完成网络故障的定位

试题答案：A;B

试题解析：封装和解封装不能缩短报文的长度，也不能完成网络故障定位（ping命令可以实现）。所以本题选A、B

47、网络管理员使用Ping来测试网络的连通性，在这个过程中下面哪些协议可能会被使用到？（）

A、ICMP B、UDP C、TCP D、ARP

试题答案：A;D

试题解析：ping命令是使用ICMP进行网络测试，传输过程会用到ARP。TCP和UDP是传输层协议，ping用不到。本题选A、D

48、如果以太网数据帧Length/Type=0X0806下列说法正确的是（）。

A、次数据帧的源MAC .地址一定不是FFFF-FFFF-FFFF

B、此数据帧为IEEE 802.3帧

C、次数据帧为Ethernet II帧

D、此数据帧的目的MAC .地址有可能是FFFF-FFFF-FFFF

试题答案：A;C

试题解析：0x0806代表ARP协议，次数据帧为Ethernet II帧，次数据帧的源MAC .地址一定不是FFFF-FFFF-FFFF。本题选A、C

49、以下应用程序中基于TCP协议的是哪一项？（）

A、Ping B、TFTP C、FTP D、HTTP

试题答案：C;D

试题解析：FTP、HTTP属于TCP协议。TFTP属于UDP协议，ping属于icmp协议。因此答案选CD。

50、路由表中某条路由信息的Proto为OSPF，则此路由的优先级一定为10。（）

A、对 B、错

试题答案：B

试题解析：ospf的路由优先级可在ospf的协议视图进行修改，默认为10。本题选错。

51、如果一个网络的网络地址为192.168.1.0，那么它的广播地址一定是192.168.1.255。（）

A、对 B、错

试题答案：B

试题解析：如果一个网络的网络地址为192.168.1.0，只有当子网掩码为255.255.255.0的时候广播地址才为192.168.1.255.子网掩码发生变化，广播地址也会发生变化。所以本题选错。

53、路由器所有的接口属于同一个广播域。（）

A、对 B、错

试题答案：B

试题解析：路由器隔离广播域，所以本题选错。

54、OSPF进程的Router ID.修改之后立即生效。（）

A、对 B、错

试题答案：B

试题解析：Router-ID改变之后，各协议需要通过手工执行reset命令才会重新选取新的Router-ID。本题选错。

55、如图所示的广播网绪中，OSPF运行在四台路由器上，且在同一区域，同一网段OSPF会自动选举一个DR，多个BDR，从而达到更好的备份效果。（）

A、对 B、错

试题答案：B

试题解析：同一区域OSPF会选举一个DR和一个BDR。本题选错。

56、路由器进行数据包转发时需要修改数据包中的目的IP地址。（）

A、对 B、错

试题答案：B

试题解析：路由器进行数据包转发时只修改源和目的MAC，并不对目的IP地址进行修改。本题错误。

57、运行OSPF协议的路由器所有接口必须属于同一个区域。（）

A、对 B、错

试题答案：B

试题解析：ospf协议是基于接口划分区域的，在同一台设备上面，不同的接口可以属于不同的区域。因此答案选错。

58、对于到达同一个目的网络的多条路径，路由器需要通过比较Prererence值的大小进行选择，如果Preference相同，则依据Cost值的大小进行选择。（）

A、对 B、错

试题答案：A

试题解析：对于到达同一个目的网络的多条路径，路由器会先比较路由条目的路由优先级，越小越优先，如果一样就比较路由条目的开销值，越小越优先。因此答案选对。

59、在广播网络上，DR和BDR都使用组播地址224.0.0.6来接收链路状态更新包。（）

A、对 B、错

试题答案：A

试题解析：在ospf的广播网络中，DR和BDR都会监听224.0.0.6这个组播地址，当DRother更新报文时，会向224.0.0.6这个组播地址发送更新报文，DR收到之后再以224.0.0.5这个组播地址同步给其他的DRother。因此答案选对。

60、运行OSPF协议的路由器先达到FULL状态,然后进行LSDB.的同步。（）

A、对 B、错

试题答案：B

试题解析：运行OSPF协议的路由器在完成LSDB同步，此时邻接状态建立成功，到达full 状态。答案为错。

MySQL基本介绍与安装

2024-11-05T08:48:00.000Z

MySQL 基本介绍

MySQL模型：层次性，网状型，关系型。

数据库（Database）是按照数据结构来组织、存储和管理数据的仓库。

RDBMS：关系型数据库管理系统。

四大基本数据类型：整型、浮点型、字符型、日期时间类型

MySQL 安装

MySQL 下载地址为： MySQL 下载。安装需要开启管理员权限。

Linux上安装MySQL

windows系统上安装MySQL

下载msi installer格式的文件后直接安装（差不多一直next就像）

省略一部分大部分都是next

这里设置root账户密码

点击Execute等待下载完成

输入 root 帐户的密码，然后单击“检查”。您将看到连接成功状态：

Mac OS系统上安装MySQL

暂时没有使用该系统，未来补上。。。。。。

MySQL 管理

启动及关闭 MySQL 服务器

查看版本：

没有登陆mysql：mysql -V
登陆成功时会提示当前数据库的版本
登录到mysql之后：select version();

Windows 系统下

启动 MySQL 服务器:

通过 “服务” 管理工具： 打开"运行"对话框（Win + R），输入 **services.msc**，找到"MySQL"服务，右击选择"启动"。
通过命令提示符： 打开命令提示符（以管理员身份），输入以下命令：

1	net start mysql

关闭MySQL服务器:

通过 “服务” 管理工具：同样打开"运行"对话框，输入 services.msc，找到 “MySQL” 服务，右击选择"停止"。
通过命令提示符： 打开命令提示符（以管理员身份），输入以下命令：

1	net stop mysql

Linux 系统下

1、启动 MySQL 服务：

使用 **systemd**命令（适用于大多数现代 Linux 发行版，如 Ubuntu、CentOS 等）：

1	sudo systemctl start mysql

使用**service**命令（在一些较旧的发行版中）：

1	sudo service mysql start

2、关闭 MySQL 服务：

使用 systemd：

1	sudo systemctl stop mysql

使用 service 命令：

1	sudo service mysql stop

3、重启 MySQL 服务：

使用 systemd：

1	sudo systemctl restart mysql

使用 service 命令：

1	sudo service mysql restart

4、检查 MySQL 服务状态：

使用 systemd命令：

1	sudo systemctl status mysql

使用 service 命令：

1	sudo service mysql status

MySQL 用户设置

在 MySQL 中，用户设置包括创建用户、设置权限、管理用户等操作。以下是一些常用的 MySQL 用户设置操作，包括创建用户、设置权限、查看和删除用户等。

创建用户

sql命令：

1	CREATE USER 'username'@'host' IDENTIFIED BY 'password';

username：用户名。
host：指定用户可以从哪些主机连接。例如，localhost 仅允许本地连接，% 允许从任何主机连接。
password：用户的密码。

授权权限

创建用户后，你需要授予他们访问权限，使用 GRANT 命令来授予权限：

1	GRANT privileges ON database_name.* TO 'username'@'host';

privileges：所需的权限，如 ALL PRIVILEGES、SELECT、INSERT、UPDATE、DELETE 等。
database_name.*：表示对某个数据库或表授予权限。database_name.* 表示对整个数据库的所有表授予权限，database_name.table_name 表示对指定的表授予权限。
TO 'username'@'host'：指定授予权限的用户和主机。

刷新权限

授予或撤销权限后，需要刷新权限使更改生效：

1	FLUSH PRIVILEGES;

查看用户权限

要查看特定用户的权限，可以使用以下命令：

1	SHOW GRANTS FOR 'username'@'host';

删除用户

如果需要删除用户，可以使用以下命令：

1	DROP USER 'username'@'host';

修改用户密码

要修改用户的密码，可以使用 ALTER USER 命令：

1	ALTER USER 'username'@'host' IDENTIFIED BY 'new_password';

管理MySQL的命令

SHOW DATABASES:
show databases;列出 MySQL 数据库管理系统的数据库列表。

select database();查看当前所在的数据库。

USE 数据库名 :
选择或者切换操作的Mysql数据库，使用该命令后所有Mysql命令都只针对该数据库。

SHOW TABLES:
show table;显示指定数据库的所有表，使用该命令前需要使用 use 命令来选择要操作的数据库。

日期和时间查询:

查看当前系统日期时间： select now();

查看当前系统日期：select curdate();

查看当前系统时间：select curtime();

查看表结构：desc 表名；

DML数据操作

2024-11-01T05:26:00.000Z

由于最近个人原因断更了2个月

数据导入

向表中装载数据（Load）

基本语法

1 2	hive(default)> load data [local] inpath '数据的 path' [overwrite] into table table_name [partition (partcol1=val1,…)];

Load data	加载数据
Local	表示从本地加载数据到hive表，否则是从HDFS加载数据到Hive表
Inpath	表是加载数据的路径
Overwrite	表示覆盖表中已有数据，否则表示追加
Into table	表示加载数据到哪张表中
Partition	表示加载数据到指定分区

实操案例
创建一张表student

hive (default)> create table student( 
id string,  
name string 
) 
row format delimited fields terminated by '\t';

1. 加载本地文件到hive

1 2	hive (default)> load data local inpath '/opt/module/hive/datas/student.txt' into table default.student;

2. 加载HDFS文件到hive中    1. 上传文件到HDFS

hive (default)> dfs -put /opt/module/hive/datas/student.txt /input;

    2. 加载HDFS上数据

hive (default)> load data inpath '/input/student.txt' into table default.student;

3. 加载数据覆盖表中已有的数据

加载数据覆盖表中已有的数据

1
2
3

hive (default)> load data inpath '/input/student.txt' overwrite into table default.student; 
FAILED: SemanticException Line 1:17 Invalid path ''/input/student.txt'': No files matching path 
hdfs://hadoop102:8020/input/student.txt

竟然报错了，信息显示文件不存在？显然，加载HDFS上的文件到hive表中，采用的类似剪切的方式，将文件拷贝到表的映射目录下。

上传文件到HDFS

1	hive (default)> dfs -put /opt/module/hive/datas/student.txt /input;

加载HDFS上数据

1	hive (default)> load data inpath '/input/student.txt' overwrite into table default.student;

查看表中数据是否被覆盖。

向表中插入数据（Insert）

创建一张表

1 2	hive (default)> create table student2(id int, name string) row format delimited fields terminated by '\t';

基本插入数据

1	hive (default)> insert into table student2 values(1,'wangwu'),(2,'zhaoliu');

将查询结果插入表中

1	hive (default)> insert overwrite table student2 select id, name from student ;

Insert into：	以追加数据的方式插入到表或分区，原有数据不会删除
Insert overwrite：	会覆盖表中已存在的数据

注意：insert不支持插入部分字段。

查询语句中创建表并加载数据（As Select）

根据查询结果创建表（查询的结果会添加到新创建的表中）

1 2	hive(default)> create table if not exists student4 as select id, name from student;

创建表时通过Location指定加载数据路径

上传数据到hdfs上

1 2	hive (default)> dfs -mkdir /input/student; hive (default)> dfs -put /opt/module/hive/datas/student.txt /input/student/student.txt;

创建表，并指定在hdfs上的位置

hive (default)> create external table if not exists student5( 
              id int, 
              name string 
) 
row format delimited fields terminated by '\t' 
location '/input/student';

查询数据

hive (default)> select * from student5; 
OK 
student5.id     student5.name 
1001    ss1 
1002    ss2 
……

注意：hive创建表时，默认时将表的名字作为默认HDFS上表对应的存储路径的名字，但是，如果你通过 localtion指定存储路径，就不会修改路径名字为表名了。如上边的表名为student5和其在HDFS上的存储路径student。

数据导出

Insert导出

将查询的结果导出到本地

1 2	hive (default)> insert overwrite local directory '/opt/module/hive/datas/export/student' select * from student;

将查询的结果格式化导出到本地

1
2
3

hive(default)> insert overwrite local directory '/opt/module/hive/datas/export/student' 
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'             select * from 
bigdata1.student;

将查询的结果导出到HDFS上(没有local)

1
2
3

hive (default)> insert overwrite directory '/output/student' 
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t'  
select * from student;

注意：insert 导出时，hive 会自动创建导出目录，但是由于是 overwrite，所以导出路径一定要写准确，否则存在误删数据的可能。

数据迁移

export 和import 命令主要用于两个Hadoop平台集群之间Hive表迁移。（元数据源+真实数据）

Export 导出到HDFS 上

hive(default)> export table default.student2 to '/地址'; 导出到哪里

Import 数据到指定Hive 表中

注意：先用export导出后，再将数据导入。

hive (default)> import table student2 from '/地址 '; 从哪里导入

DDL数据定义

2024-08-22T05:29:34.000Z

先一下唠嗑：最近更新的话会比较慢~~一个月一次~~，也是比较忙的。月底有可能会写一个小总结及提一下未来的小目标。博客我也是会偶尔看一下的！
~~言归正传以免忘记，~~以下的数据库都是test，用的是虚拟机直接复制的代码有可能会看起来有点别扭，有啥补充的，可以指点指点！

创建数据库

创建数据库语法：

CREATE DATABASE [IF NOT EXISTS] database_name 
[COMMENT database_comment] 
[LOCATION hdfs_path] 
[WITH DBPROPERTIES (property_name=property_value, ...)];

创建一个数据库，数据库在HDFS上的默认存储路径是/user/hive/warehouse/*.db。

1	hive (default)> create database test;

避免要创建的数据库已经存在错误，增加if not exists判断。（标准写法）

hive (default)> create database test; 
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. Database 
db_hive already exists 
hive (default)> create database if not exists test;

创建一个数据库，指定数据库在HDFS上存放的位置

1	hive (default)> create database test2 location '/test2.db';

查询数据库

显示数据库

显示数据库

hive(default)> show databases;

过滤显示查询到数据库

hive(default)> show databases like 'test*';

查看数据库详情

显示数据库信息

hive(default)> desc database test;

显示数据库详细信息

hive(default)> desc database extended test;

创建数据库test3，并设置其createtime属性

hive(default)> create database test3 with dbproperties('createtime'='20240819');

切换当前数据库

hive (default)> use test;

修改数据库

用户可以使用 ALTER DATABASE 命令为某个数据库的 DBPROPERTIES 设置键-值对属性值，来描述这个数据库的属性信息。数据库其他的元数据信息都是不可以修改的，包括数据库名和数据库所在的目录位置。
hive (default)> alter database test set dbproperties('createtime'='20211022');

删除数据库

删除空数据库

hive(default)>drop database test2;

如果删除的数据库不存在，最好采用 if exists判断数据库是否存在

hive(default)> drop database if exists test2;

如果数据库不为空，可以采用cascade命令，强制删除

hive(default)> drop database test; (以下是报错！！！)
FAILED: Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. 
InvalidOperationException(message:Database test is not empty. One or more tables exist.) 
hive(default)> drop database test cascade;

创建表

语法 create table …

CREATE [EXTERNAL] TABLE [IF NOT EXISTS] table_name  
[(col_name data_type [COMMENT col_comment], ...)]  
[COMMENT table_comment]  
[PARTITIONED BY (col_name data_type [COMMENT col_comment], ...)]  
[CLUSTERED BY (col_name, col_name, ...)  
[SORTED BY (col_name [ASC|DESC], ...)] INTO num_buckets BUCKETS]  
[ROW FORMAT row_format]  
[STORED AS file_format]  
[LOCATION hdfs_path] 
[TBLPROPERTIES (property_name=property_value, ...)] 
[AS select_statement] 
[LIKES existing_table_or_view_name]

字段解释说明

CREATE TABLE	创建一个指定名字的表。如果相同名字的表已经存在，则抛出异常；用户可以用 IF NOT EXISTS 选项来忽略这个异常
EXTERNAL	1. 关键字可以让用户创建一个外部表在建表的同时可以指定一个指向实际数据的路径（LOCATION）2. 在删除表的时候内部表的元数据和数据会被一起删除，外部表只删除元数据，不删除数据。
COMMENT	为表和列添加注释。
PARTITIONED BY	创建分区表
CLUSTERED BY	创建分桶表
SORTED BY	不常用，对桶中的一个或多个列另外排序
ROW FROMAT	- ROW FORMAT DELIMITED [FIELDS TERMINATED BY char] [COLLECTION ITEMS TERMINATED BY char] [MAP KEYS TERMINATED BY char] [LINES TERMINATED BY char] \| SERDE serde_name [WITH SERDEPROPERTIES (property_name=property_value, property_name=property_value, … )]- Fields 指定字段之间的分隔符 Collection 用于指定集合中元素间的分隔符 Map 用于指定map集合中键值对间的分隔符 Lines 用于指定每行记录间的分隔符 SerDe是Serialize/Deserialize的简称用户在建表时可以自定义SerDe或使用自带的 SerDe 若未指定Row Format，则用自带的SerDe
STORE AS	指定存储文件类型常用的文件存储类型： SEQUENCEFILE（二进制序列文件）、TEXTFILE（文本）、RCFILE（列式存储格式文件）如：store as textfile、store as sequencefile
LOCATION	指定表在HDFS上的存储位置
AS	后跟查询语句，根据查询语句结果创建表
LIKE	允许用户复制现有的表结构，但是不复制数据

管理表

内部表

理论

默认创建的表都是所谓的管理表，有时也被称为内部表。
管理表，Hive会控制着元数据和真实数据的生命周期。
Hive默认会将这些表的数据存储在hive.metastore.warehouse.dir定义目录的子目录下。
当我们删除一个管理表时，Hive也会删除这个表中数据。
管理表不适合和其他工具共享数据。

案例实操

创建数据文件，在/opt/module/hive/datas目录下创建文件student.txt，编辑如下内容：

[root@hadoop datas]$ vim student.txt 
1001 ss1 
1002 ss2 
1003 ss3 
1004 ss4 
1005 ss5 
1006 ss6 
1007 ss7 
1008 ss8 
1009 ss9

在hive中创建内部表student

create table if not exists student( 
id int, 
name string 
) 
row format delimited 
fields terminated by '\t' 
stored as textfile 
location '/user/hive/warehouse/student';

查询表的类型

hive (default)> desc formatted student;

根据查询结果创建表（查询的结果会添加到新创建的表中）

hive(default)> create table if not exists student2 as select id, name from student;

根据已经存在的表结构创建表

hive(default)> create table if not exists student3 like student;

查询表的类型

hive (default)> desc formatted student2;

删除表student2后，观察表的元数据和数据文件是否还存在

hive(default)> drop table student2;

外部表

理论

因为表是外部表，所以Hive并非认为其完全拥有这份数据。删除该表并不会删除掉这份数据，不过描述表的元数据信息会被删除掉。使用场景：每天将收集到的网站日志定期流入HDFS文本文件。在外部表（原始日志表）的基础上做大量的统计分析，用到的中间表、结果表使用内部表存储，数据通过 SELECT+INSERT进入内部表。外部表多用于存储原始数据，为多个部门、小组所使用，采用外部表共易共享数据。

案例实操

在/opt/module/hive/datas路径上，创建teacher.txt文件，并输入如下内容。

1001 teacher1 
1002 teacher2 
1003 teacher3 
1004 teacher4 
1005 teacher5

上传数据到HDFS

1 2	[root@hadoop datas]$ hadoop fs -mkdir -p /school/teacher [root@hadoop datas]$ hadoop fs -put teacher.txt /school/teacher

在hive中创建外部表teacher

hive (default)> 
create external table if not exists teacher( 
    id int,  
    name string 
) 
row format delimited fields terminated by '\t' 
location '/school/teacher';

查看创建的表

hive (default)> show tables;

查看表格式化信息

hive (default)> desc formatted dept;

删除外部表，观察表的元数据和相应hdfs中的数据

hive (default)> drop table dept;

管理表与外部表的互相转换

查询表的类型

1 2	hive (default)> desc formatted student2; Table Type: MANAGED_TABLE

修改内部表student2为外部表

1	alter table student2 set tblproperties('EXTERNAL'='TRUE');

查询表的类型

1 2	hive (default)> desc formatted student2; Table Type: EXTERNAL_TABLE

修改外部表student2为内部表

1	alter table student2 set tblproperties('EXTERNAL'='FALSE');

查询表的类型

1 2	hive (default)> desc formatted student2; Table Type: MANAGED_TABLE

修改表

重命名表

语法

1	ALTER TABLE table_name RENAME TO new_table_name

实操案例

1	hive (default)> alter table student3 rename to student4;

增加、修改和删除表分区

之后的分区表基本操作详情

增加/修改/替换列信息

语法

更新列

1	ALTER TABLE table_name CHANGE [COLUMN] col_old_name col_new_name column_type [COMMENT col_comment] [FIRST\|AFTER column_name]

增加和替换列

1	ALTER TABLE table_name ADD\|REPLACE COLUMNS (col_name data_type [COMMENT col_comment], ...)

注：ADD是代表新增一字段，字段位置在所有列后面(partition列前)，REPLACE则是表示替换表中所有字段。 REPLACE使用的时候，字段的类型要跟之前的类型对应上，数量可以减少或者增加，其中就包含了更新列、增加列、删除列的功能。

实操案例

查询表结构

hive(default)> desc test2; 
OK 
col_name        data_type       comment 
id                      int

更新列：将列名id修改为student_id，类型不变。

hive(default)> alter table test2 change column id student_id int; 
OK 
Time taken: 0.083 seconds 
hive(default)> desc test2; 
OK 
col_name        data_type       comment 
student_id              int

更新列：不修改列名，仅修改列的类型为string。

hive(default)> alter table test2 change column student_id student_id string; 
OK 
Time taken: 0.083 seconds 
hive(default)> desc test2; 
OK 
col_name        data_type       comment 
student_id

新增列：向test2表中新增一列，列名为name，类型为string。

hive (default)> alter table test2 add columns(name string);
hive(default)> desc test2; 
OK 
col_name        data_type       comment 
student_id              string                                       
name                    string

调整列的位置:现在想让name的列在最前面，做如下操作：

hive(default)> alter table test2 change name name string first; 
OK 
Time taken: 0.139 seconds 
hive (default)> desc test2; 
OK 
col_name        data_type       comment 
name                    string                                       
student_id              string                                       
Time taken: 0.036 seconds, Fetched: 2 row(s)

调整列的位置:将name更新到指定列的后面，操作如下:

hive (default)> alter table test2 change name name string after student_id; 
OK 
Time taken: 0.069 seconds 
hive (default)> desc test2; 
OK 
col_name        data_type       comment 
student_id              string                                       
name                    string                                       
Time taken: 0.033 seconds, Fetched: 2 row(s)

替换列（替换所有的列）

hive (default)> alter table test2 replace columns(id double); 
OK 
Time taken: 0.058 seconds 
hive (default)> desc test2; 
OK 
col_name        data_type       comment 
id                      double                                       
Time taken: 0.032 seconds, Fetched: 1 row(s)

删除表

删除表的操作相对简单
hive (default)> drop table test2;

清除表中数据（Truncate）

注意：Truncate只能删除管理表，不能删除外部表中数据
hive (default)> truncate table student;

Hive数据类型

2024-08-17T13:53:03.000Z

基本数据类型

Hive数据类型	Java数据类型	长度	例子
TINYINT	byte	1byte有符号整数	20
SMALINT	short	2byte有符号整数	20
`INt`	int	4byte有符号整数	20
`BIGINT`	long	8byte有符号整数	20
BOOLEAN	boolean	布尔类型，true或者false	TRUE FALSE
FLOAT	float	单精度浮点数	3.14159
`DOUBLE`	double	双精度浮点数	3.14159
`STRING`	string	字符系列。可以指定字符集。可以使用单引号或者双引号	‘now is the time’ “for all good men“

对于Hive的String类型相当于数据库的varchar类型，该类型是一个可变的字符串，不过它不能声明其中最多能存储多少个字符，理论上它可以存储2GB的字符数.

集合数据类型

数据类型	描述	语法示例
STRUCT	和c语言中的struct类似，都可以通过“点”符号访问元素内容。例如：如果某个列的数据类型是STRUCT{first STRING, last STRING},那么第1个元素可以通过字段.first来引用。	struct() 例如： struct< street:string, city:string >
MAP	MAP是一组键-值对元组集合，使用数组表示法可以访问数据。例如：如果某个列的数据类型是MAP，其中键->值对是’first’->’John’和’last’->’ Doe’，那么可以通过字段名[‘last’]获取最后一个元素	map() 例如： map< string, int >
ARRAY	数组是一组具有相同类型和名称的变量的集合。这些变量称为数组的元素，每个数组元素都有一个编号，编号从零开始。例如：数组值为[‘John’, ‘Doe’]，那么第2个元素可以通过数组名[1]进行引用。	Array() 例如：array< string >

Hive有三种复杂数据类型ARRAY、MAP 和 STRUCT。ARRAY和MAP与Java中的Array和Map类似，而 STRUCT与C语言中的Struct类似，它封装了一个命名字段集合，复杂数据类型允许任意层次的嵌套.

类型转换

Hive 的基本数据类型是可以进行隐式转换的，类似于Java的类型转换

例如:某表达式使用INT类型，TINYINT会自动转换为INT类型，但是Hive不会进行反向转化例如，某表达式使用TINYINT 类型，INT 不会自动转换为TINYINT 类型，它会返回错误，除非使用CAST 操作。

隐式类型转换规则如下

任何整数类型都可以隐式地转换为一个范围更广的类型，如INT可以转换成BIGINT。
所有整数类型、FLOAT和STRING类型都可以隐式地转换成DOUBLE。
TINYINT、SMALLINT、INT 都可以转换为FLOAT。
BOOLEAN 类型不可以转换为任何其它的类型。

可以使用CAST操作显示进行数据类型转换例如：CAST(‘1’ AS INT)将把字符串’1’ 转换成整数1；如果强制类型转换失败，如执行CAST(‘X’ AS INT)，表达式返回空值 NULL。

hive(default)> select '1'+2, cast('1'as int) + 2; 
+------+------+--+ 
| _c0  | _c1  | 
+------+------+--+ 
| 3.0  | 3    | 
+------+------+--+

浅小兮

Docker命令-卷命令

docker volume 命令

常用 docker volume 命令

docker volume ls 命令

docker volume inspect 命令

docker volume create 命令

docker volume rm 命令

docker volume prune 命令

使用场景

Docker命令-网络命令

docker network 命令

常用 docker network 命令

docker network ls 命令

docker network inspect 命令

docker network create 命令

docker network rm 命令

docker network connect 命令

docker network disconnect 命令

使用场景

Docker命令-Docker Compose

docker compose run 命令

语法

实例

docker compose rm 命令

语法

实例

docker compose ps 命令

语法

输出信息

实例

docker compose build 命令

语法

实例

docker compose up 命令

语法

实例

docker compose ls 命令

语法

实例

docker compose start 命令

语法

实例

docker compose restart 命令

语法

实例

Docker命令-info_version

docker info 命令

语法

实例

输出解释

docker version 命令

语法

实例

输出解释

Docker命令-本地镜像管理

Docker images 命令

语法

实例

常用场景

Docker rmi 命令

语法

实例

常用场景

注意事项

Docker tag 命令

语法

实例

为镜像打标签

注意事项

Docker build 命令

语法

实例 - 使用 Dockerfile 构建镜像

注意事项

Docker history 命令

语法

实例

操作实例

注意事项

Docker save 命令

常用 `docker volume` 命令

`docker volume ls` 命令

常用 `docker network` 命令

`docker network ls` 命令

`docker network inspect` 命令

`docker network create` 命令

`docker network rm` 命令

`docker network connect` 命令

`docker network disconnect` 命令