### Linux 安装 Docker 教程

Docker 是一个开源的容器化平台，用于自动化应用程序的部署、扩展和管理。它使得开发人员能够将应用及其依赖项打包成一个标准化的容器中，从而在任何环境中一致运行。

以下是安装和使用 Docker 的详细步骤和一些常用命令的说明。

#### 一、安装 Docker

##### 1. 更新系统软件包
在开始安装 Docker 之前，确保系统是最新的，运行以下命令更新软件包列表：



```bash
sudo apt-get update  # 对于 Debian/Ubuntu 系统
sudo yum update      # 对于 CentOS/RHEL 系统
```

##### 2. 安装必要的依赖包
在安装 Docker 之前，必须确保系统安装了 `apt-transport-https` 和 `ca-certificates` 等依赖。

对于 **Ubuntu/Debian** 系统：

```bash
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
```

对于 **CentOS/RHEL** 系统：

```bash
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
```

##### 3. 安装 Docker

###### 对于 **Ubuntu/Debian** 系统：
使用官方安装脚本自动安装

```bash
curl -fsSL https://test.docker.com -o test-docker.sh
sudo sh test-docker.sh
```

###### 对于 **CentOS/RHEL** 系统：
使用官方安装脚本自动安装

```bash
curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
```

##### 4. 启动 Docker 服务

在安装完成后，启动 Docker 服务并设置开机启动：

```bash
sudo systemctl start docker
sudo systemctl enable docker
```

##### 5. 验证安装

安装完成后，使用以下命令验证 Docker 是否正确安装：

```bash
docker --version
```

##### 6. 设置镜像代理

安装完成后，修改/etc/docker/daemon.json文件，使用国内的镜像代理，加速镜像下载

```bash
sudo vim /etc/docker/daemon.json
```
```json
{
  "registry-mirrors": ["https://mirror.ccs.tencentyun.com"],
  "log-driver":"json-file",
  "log-opts": {"max-size":"1000m", "max-file":"3"}
}

```

如果显示 Docker 版本信息，则说明 Docker 已成功安装。

#### 二、Docker 常用命令

安装完 Docker 后，下面是一些常用的 Docker 命令来帮助你管理容器和镜像。

##### 1. **查看 Docker 服务状态**

```bash
sudo systemctl status docker
```

##### 2. **启动 Docker 服务**

```bash
sudo systemctl start docker
```

##### 3. **停止 Docker 服务**

```bash
sudo systemctl stop docker
```

##### 4. **查看 Docker 版本**

```bash
docker --version
```

##### 5. **运行第一个 Docker 容器**

Docker 容器是运行的实例。使用下面的命令来运行一个简单的容器：

```bash
docker run hello-world
```

该命令将从 Docker Hub 下载一个名为 `hello-world` 的镜像，并启动一个容器运行它。第一次运行时，Docker 会自动从镜像仓库下载并执行。

##### 6. **拉取镜像**

Docker 提供了许多公共镜像，可以使用 `docker pull` 命令从 Docker Hub 拉取镜像。例如，拉取 `nginx` 镜像：

```bash
docker pull nginx
```

##### 7. **查看本地镜像**

可以通过以下命令查看当前系统上已经下载的镜像：

```bash
docker images
```

##### 8. **启动容器**

启动一个容器并运行指定的命令。例如，启动一个 Nginx 容器：

```bash
docker run -d -p 8080:80 --name mynginx nginx
```

这里的参数解释：
- `-d`：后台运行容器。
- `-p 8080:80`：将宿主机的 8080 端口映射到容器的 80 端口。
- `--name mynginx`：为容器指定一个名称。

##### 9. **查看正在运行的容器**

查看当前正在运行的容器：

```bash
docker ps
```

查看所有容器（包括停止的容器）：

```bash
docker ps -a
```

##### 10. **停止容器**

停止一个正在运行的容器：

```bash
docker stop <容器ID或容器名称>
```

例如，停止名为 `mynginx` 的容器：

```bash
docker stop mynginx
```

##### 11. **删除容器**

删除停止的容器：

```bash
docker rm <容器ID或容器名称>
```

例如，删除名为 `mynginx` 的容器：

```bash
docker rm mynginx
```

##### 12. **删除镜像**

删除不再需要的镜像：

```bash
docker rmi <镜像ID或镜像名称>
```

例如，删除 `nginx` 镜像：

```bash
docker rmi nginx
```

##### 13. **查看容器日志**

查看容器的日志信息：

```bash
docker logs <容器ID或容器名称>
```

##### 14. **进入容器的交互模式**

如果需要进入正在运行的容器，可以使用 `docker exec` 命令：

```bash
docker exec -it <容器ID或容器名称> /bin/bash
```

进入容器后，你可以像在普通 Linux 系统中一样进行操作。

##### 15. **查看容器的资源使用情况**

使用以下命令查看容器的资源使用情况：

```bash
docker stats <容器ID或容器名称>
```

##### 16. **构建 Docker 镜像**

如果你有一个自定义的 Dockerfile 文件，可以使用以下命令构建自己的镜像：

```bash
docker build -t <镜像名称>:<标签> .
```

例如：

```bash
docker build -t myapp:v1 .
```

##### 17. **保存和加载 Docker 镜像**

保存镜像到一个 tar 文件：

```bash
docker save -o <文件名>.tar <镜像名称>:<标签>
```

加载镜像：

```bash
docker load -i <文件名>.tar
```

##### 18. **清理未使用的资源**

清理所有停止的容器、未使用的镜像和未使用的网络资源：

```bash
docker system prune
```

你也可以使用 `docker system prune -a` 来删除所有未使用的镜像。

#### 三、总结

以上教程涵盖了在 Linux 上安装 Docker 的基本步骤以及一些常用的 Docker 命令。Docker 是一个非常强大的容器化平台，能帮助开发者在隔离的环境中运行应用程序。掌握这些基本命令后，你可以开始使用 Docker 来管理你的应用程序容器，简化部署和运维工作。

Linux 安装 Docker 教程

# Elasticsearch详解

Elasticsearch 是一个开源的分布式搜索和分析引擎，广泛应用于全文搜索、日志分析、实时数据处理等领域。它基于 Apache Lucene 构建，具有高效的查询、存储和分析能力，能够处理海量数据。Elasticsearch 采用了 RESTful API 作为与外部系统交互的方式，使得用户可以通过简单的 HTTP 请求进行操作。

在本文中，我们将深入探讨 Elasticsearch 的基础概念和其底层实现原理，并重点介绍如何通过 RESTful API 在 Elasticsearch 中进行常见操作。



---

## Elasticsearch 基础概念

我们首先需要了解其几个关键概念。

### 1. 索引（Index）

索引是 Elasticsearch 中的基本数据单元，相当于关系数据库中的数据库。在 Elasticsearch 中，索引是用来组织数据的容器，它包含了多份数据和配置。每个索引都有一个独立的配置和映射，允许用户定义字段的类型、分析方式等。

### 2. 文档（Document）

文档是 Elasticsearch 中的数据存储单元，相当于关系型数据库中的行。每个文档包含一组字段（Field），这些字段描述了文档的各种信息。文档是以 JSON 格式进行存储的，可以通过唯一的 ID 来标识。

### 3. 映射（Mapping）

映射定义了文档中字段的结构和数据类型。它类似于关系型数据库中的表结构定义，告诉 Elasticsearch 如何存储和索引数据。

### 4. 集群（Cluster）

Elasticsearch 集群由多个节点（Node）组成。每个集群有一个唯一的名字，多个节点共同工作，分担数据存储、索引、查询等任务。

### 5. 分片与副本（Shard & Replica）

每个索引在内部会被分割成多个分片（Shard），而分片可以有副本（Replica）。分片允许数据分布到多个节点上，副本提高了数据的可用性和查询性能。

---

### Elasticsearch 底层原理解析

Elasticsearch 是一个分布式搜索引擎，其底层实现基于 Apache Lucene，采用分布式架构来进行数据存储、索引和搜索。在理解 Elasticsearch 的使用之前，首先了解其底层原理对于优化和深入理解其性能至关重要。在这一部分，我们将详细讲解 Elasticsearch 的底层架构和实现原理。

---

## 1. 数据存储与索引结构

Elasticsearch 的底层实现依赖于 **倒排索引**（Inverted Index）机制，这种索引结构在搜索引擎中是非常常见的。倒排索引的核心思想是，记录文档中每个词项（Term）出现的位置，从而可以快速检索包含特定词项的文档。

### 1.1 倒排索引（Inverted Index）

在 Elasticsearch 中，数据首先被存储为文档，每个文档包含若干个字段。对于每个字段，Elasticsearch 会根据文档内容生成倒排索引。简单来说，倒排索引的构建过程如下：

- **分词**：Elasticsearch 将字段中的文本分解为多个词项（Token）。对于文本字段，Elasticsearch 会使用分词器（Analyzer）将文本拆分为一个个单词。
- **倒排列表**：对于每个词项，Elasticsearch 会记录它在所有文档中的出现位置（文档ID）。这种方式的优点是，当查询某个词项时，能够非常高效地找到包含该词项的文档。

举个简单的例子，如果你有两个文档：

```json
{
  "id": 1,
  "content": "Elasticsearch is a distributed search engine"
}

{
  "id": 2,
  "content": "Elasticsearch supports distributed searches"
}
```

Elasticsearch 会为 `content` 字段建立如下倒排索引：

| Term         | Document IDs  |
|--------------|---------------|
| elasticsearch| [1, 2]        |
| is           | [1]           |
| a            | [1]           |
| distributed  | [1, 2]        |
| search       | [1, 2]        |
| engine       | [1]           |
| supports     | [2]           |
| searches     | [2]           |

当用户查询 `distributed` 时，Elasticsearch 只需要查看倒排索引，快速返回包含 `distributed` 的文档ID，即 `1` 和 `2`。

### 1.2 分片（Shard）与副本（Replica）

为了使 Elasticsearch 能够处理海量数据并具有高可用性，Elasticsearch 对数据进行了分片和复制的设计。

#### 分片（Shard）

每个 Elasticsearch 索引都会被分为多个分片（Shard）。每个分片是一个独立的 Lucene 实例，负责存储数据和进行索引。因此，数据被水平划分到多个分片中，从而实现了数据的分布式存储。每个分片都有一个主分片（Primary Shard），用于存储原始数据。

#### 副本（Replica）

为了提高数据的可用性和查询的性能，Elasticsearch 还允许创建副本（Replica）。副本是主分片的完整拷贝，可以分布在集群中的其他节点上。副本的作用有两个：
1. 提高查询性能：多个副本可以分担查询负载，提高搜索速度。
2. 提高容错性：如果某个主分片所在的节点出现故障，副本可以保证数据不会丢失。

通常，副本数量可以根据实际需要配置，副本和主分片的数量一起决定了索引的整体性能和容错能力。

---

## 2. 集群与节点管理

Elasticsearch 作为分布式系统，多个节点组成了一个集群（Cluster），所有的节点都共同工作，共享数据。集群中的每个节点都有一个唯一的名称。Elasticsearch 会根据数据量、查询请求等情况动态分配节点角色，确保集群的高可用性和负载均衡。

### 2.1 节点（Node）

Elasticsearch 集群中的每个节点都可以承担不同的角色，常见的节点角色有：

- **主节点（Master Node）**：负责管理集群状态和元数据，协调索引的创建、删除，管理分片和副本的分配等。一个集群中通常会有多个主节点，但只有一个主节点负责管理整个集群。
- **数据节点（Data Node）**：负责存储数据，并处理与数据相关的所有操作，如索引、查询、聚合等。数据节点是 Elasticsearch 的核心，承担了大部分计算和存储任务。
- **协调节点（Coordinating Node）**：并不是特定的角色，而是任何接收到请求的节点。在 Elasticsearch 中，所有的节点都可以充当协调节点，协调节点负责将请求路由到适当的数据节点，并将数据节点的响应返回给客户端。
- **机器学习节点（Machine Learning Node）**：用于处理机器学习相关的任务，如预测分析、异常检测等。

### 2.2 集群状态管理

Elasticsearch 集群中的节点会定期交换状态信息，以保证集群状态的一致性。当集群状态发生变化时，例如增加新节点或数据节点的负载过重，集群会自动进行数据的迁移和负载均衡。

---

## 3. 查询执行与性能优化

Elasticsearch 的查询过程是高度优化的，使用了多种技术来提高查询的速度和精度。

### 3.1 查询流程

当用户发送查询请求时，Elasticsearch 会执行以下步骤：

1. **路由**：查询请求会根据索引和分片策略确定查询的目标分片。Elasticsearch 使用路由策略（默认是哈希路由）将请求发送到合适的分片。
2. **查询执行**：一旦请求被路由到目标分片，每个分片会并行执行查询。分片是一个独立的 Lucene 实例，所以查询将在每个分片内执行，Lucene 会利用倒排索引进行高效查询。
3. **聚合与排序**：对于涉及聚合和排序的查询，Elasticsearch 会首先执行这些操作，合并各个分片的结果，然后返回最终的结果。
4. **查询合并与返回**：所有分片的查询结果会合并，并且如果涉及排序或分页，Elasticsearch 会在合并结果的基础上执行排序和分页操作。

### 3.2 性能优化

Elasticsearch 提供了多种方法来优化查询性能：

- **过滤器（Filter）与查询（Query）分离**：Elasticsearch 将过滤操作和查询操作分开处理，过滤操作通常不需要评分，因此执行得更快。将过滤器放在查询前执行，可以避免重复计算。
- **缓存（Caching）**：Elasticsearch 会缓存一些查询结果，特别是过滤操作的结果。如果某个查询重复出现，Elasticsearch 会直接从缓存中获取结果，避免重复计算。
- **字段数据类型优化**：根据字段的数据类型，选择合适的字段映射（Mapping），确保字段索引和存储的效率。
- **分片与副本数的调整**：根据集群的规模和查询量，合理调整分片和副本的数量，以达到最优的性能。

---

## 4. 数据一致性与事务

Elasticsearch 是一个分布式系统，数据的一致性和事务管理是一个复杂的问题。为了提供高可用性和性能，Elasticsearch 使用了 **最终一致性**（Eventual Consistency）模型，而不是传统的 **强一致性** 模型。

- **数据写入一致性**：Elasticsearch 中的写操作采用了 **内部一致性保证**，即每个节点会在本地存储数据并等待主节点确认写操作是否成功。此时数据在分片之间传播，不保证写入的一致性，而是保证最终一致性。
- **事务管理**：由于 Elasticsearch 是基于分布式架构的，它并不支持传统的 ACID 事务。对于需要多步骤一致性的操作，建议将它们分布在多个单独的写操作中，通过 **最终一致性** 保证数据的一致性。

---

## Elasticsearch 的 RESTful API

Elasticsearch 提供了全面的 RESTful API 接口，通过 HTTP 请求即可完成创建、查询、更新、删除数据等操作。API 使用 JSON 格式进行数据交互，支持常见的 HTTP 方法：`GET`、`POST`、`PUT`、`DELETE`。

### 1. 创建索引（Index）

要向 Elasticsearch 存储数据，首先需要创建一个索引。可以通过 `PUT` 请求来创建一个新索引。

```bash
# 创建一个名为 "my_index" 的索引
PUT /my_index
```

成功响应示例：

```json
{
  "acknowledged": true
}
```

### 2. 向索引中插入文档（Document）

在 Elasticsearch 中，文档是存储的基本单元。你可以通过 `POST` 或 `PUT` 请求向索引中插入数据。

```bash
# 向 "my_index" 索引中插入一个文档
POST /my_index/_doc/1
{
  "title": "Elasticsearch Basics",
  "content": "This is a basic example of Elasticsearch usage"
}
```

成功响应示例：

```json
{
  "_index": "my_index",
  "_id": "1",
  "_version": 1,
  "result": "created"
}
```

### 3. 查询索引中的文档（Search）

你可以使用 `GET` 请求对索引进行查询，Elasticsearch 提供了强大的查询功能，包括匹配查询、全文搜索、聚合等。

```bash
# 查询 "my_index" 中包含 "Elasticsearch" 的文档
GET /my_index/_search
{
  "query": {
    "match": {
      "content": "Elasticsearch"
    }
  }
}
```

查询响应示例：

```json
{
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "hits": [
      {
        "_index": "my_index",
        "_id": "1",
        "_score": 1.0,
        "_source": {
          "title": "Elasticsearch Basics",
          "content": "This is a basic example of Elasticsearch usage"
        }
      }
    ]
  }
}
```

### 4. 更新文档（Update）

更新现有的文档可以使用 `POST` 请求的 `_update` API，用户可以指定字段来更新。

```bash
# 更新文档 ID 为 1 的文档，修改 "title" 字段
POST /my_index/_doc/1/_update
{
  "doc": {
    "title": "Updated Elasticsearch Basics"
  }
}
```

更新响应示例：

```json
{
  "_index": "my_index",
  "_id": "1",
  "_version": 2,
  "result": "updated"
}
```

### 5. 删除文档（Delete）

如果要删除文档，可以使用 `DELETE` 请求删除指定的文档。

```bash
# 删除文档 ID 为 1 的文档
DELETE /my_index/_doc/1
```

删除响应示例：

```json
{
  "_index": "my_index",
  "_id": "1",
  "_version": 3,
  "result": "deleted"
}
```

### 6. 批量操作（Bulk）

对于需要批量处理的情况，Elasticsearch 提供了批量操作 API，允许一次性提交多个请求。

```bash
# 批量操作，插入两个文档
POST /my_index/_bulk
{ "index": { "_id": "2" } }
{ "title": "Elasticsearch Introduction", "content": "Learn the basics of Elasticsearch." }
{ "index": { "_id": "3" } }
{ "title": "Advanced Elasticsearch", "content": "Explore advanced topics in Elasticsearch." }
```

批量操作响应示例：

```json
{
  "took": 10,
  "errors": false,
  "items": [
    { "index": { "_index": "my_index", "_id": "2", "_version": 1, "result": "created" } },
    { "index": { "_index": "my_index", "_id": "3", "_version": 1, "result": "created" } }
  ]
}
```

### 7. 聚合查询（Aggregation）

Elasticsearch 支持聚合查询功能，可以对数据进行复杂的统计分析。

```bash
# 查询 "my_index" 中的文档，并聚合统计 "title" 字段中出现的不同值
GET /my_index/_search
{
  "size": 0,
  "aggs": {
    "unique_titles": {
      "terms": {
        "field": "title.keyword"
      }
    }
  }
}
```

聚合查询响应示例：

```json
{
  "aggregations": {
    "unique_titles": {
      "buckets": [
        { "key": "Elasticsearch Basics", "doc_count": 1 },
        { "key": "Elasticsearch Introduction", "doc_count": 1 }
      ]
    }
  }
}
```

---

## 总结

Elasticsearch 是一个功能强大的搜索引擎，通过其 RESTful API，用户可以方便地进行数据的索引、查询、更新、删除等操作。Elasticsearch 的底层基于分布式架构，使得它在处理大规模数据时依然能够保持高效的性能。

Elasticsearch 的底层原理包括倒排索引、分片副本机制、集群管理等，构成了它高效、可扩展、分布式的特性。它通过倒排索引的设计，实现了高效的查询性能；通过分片和副本的机制，实现了大数据的存储和高可用性；同时，Elasticsearch 提供的 RESTful API 简化了用户与系统的交互，使得它能够广泛应用于日志分析、全文搜索、实时数据分析等场景。

理解 Elasticsearch 的底层原理，可以帮助开发者更好地配置和使用 Elasticsearch，在处理复杂的查询、分析任务时更加得心应手。同时，掌握 Elasticsearch 的性能优化方法，可以显著提升应用的响应速度和可扩展性。

本文介绍了 Elasticsearch 的基础概念，并通过具体的 RESTful API 示例展示了如何与 Elasticsearch 交互，包括创建索引、插入和查询文档、更新和删除文档等操作。通过这些基础操作，你可以快速上手使用 Elasticsearch 进行数据存储和搜索，处理各种复杂的查询和分析任务。

希望本篇博客能够帮助你理解 Elasticsearch 的基本原理和如何通过 RESTful API 使用它。如果你有任何问题或需要进一步了解，可以随时与我联系。

Elasticsearch详解

# 使用 Docker 安装和使用 RabbitMQ

## 一、前置条件

1. **操作系统要求**：适用于 CentOS 7 或更高版本的 Linux 系统。
2. **安装 Docker**：确保系统已安装并启动 Docker。如果还未安装，请参考 Docker 官方文档或使用以下命令安装：

   ```bash
   sudo yum install -y yum-utils device-mapper-persistent-data lvm2
   sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
   sudo yum install -y docker-ce docker-ce-cli containerd.io
   ```

   启动 Docker 服务：

   ```bash
   sudo systemctl start docker
   sudo systemctl enable docker
   ```



## 二、RabbitMQ 安装和启动

RabbitMQ 是一个流行的消息中间件，Docker 提供了官方的 RabbitMQ 镜像，可以方便地部署和管理。

### 1. 拉取 RabbitMQ 镜像

使用以下命令拉取 RabbitMQ 官方 Docker 镜像：

```bash
sudo docker pull rabbitmq:3.9.21
```

### 2. 启动 RabbitMQ 容器

使用 Docker 启动一个新的 RabbitMQ 容器。您可以使用以下脚本来启动 RabbitMQ：

```bash
#!/bin/bash
# docker启动rabbitmq脚本，记得进入容器执行：rabbitmq-plugins enable rabbitmq_management方可使用web页面
# 停止旧容器运行
docker stop rabbitmq
# 删除旧容器
docker rm rabbitmq

# 启动 RabbitMQ 容器
docker run -itd \
--privileged=true \
-p 25672:5672 \  # RabbitMQ 内部的 AMQP 通信端口
-p 15672:15672 \  # RabbitMQ 管理界面端口
-e RABBITMQ_DEFAULT_USER=username \  # 默认用户名
-e RABBITMQ_DEFAULT_PASS=password \  # 默认密码
-e RABBITMQ_DEFAULT_VHOST=dev \  # 默认虚拟主机
--name rabbitmq \  # 容器名称
--restart=always \  # 容器重启策略
rabbitmq:3.9.21  # 使用的 RabbitMQ 镜像版本

# 启用 RabbitMQ 管理插件
docker exec rabbitmq rabbitmq-plugins enable rabbitmq_management

exit 0
```

### 3. 脚本说明

- `docker stop rabbitmq`：停止旧的 RabbitMQ 容器（如果存在）。
- `docker rm rabbitmq`：删除旧的 RabbitMQ 容器。
- `docker run`：启动新的 RabbitMQ 容器，并设置一些环境变量和配置：
  - `-p 25672:5672`：映射 RabbitMQ 的 AMQP 通信端口 `5672` 到宿主机的 `25672` 端口。
  - `-p 15672:15672`：映射 RabbitMQ 管理 UI 的端口 `15672` 到宿主机的相同端口。
  - `-e RABBITMQ_DEFAULT_USER=用户名`：设置 RabbitMQ 的默认用户名。
  - `-e RABBITMQ_DEFAULT_PASS=密码`：设置 RabbitMQ 的默认密码。
  - `-e RABBITMQ_DEFAULT_VHOST=dev`：设置默认虚拟主机 `dev`。
  - `--restart=always`：设置容器自动重启策略，确保容器在崩溃或系统重启后自动启动。

- `docker exec rabbitmq rabbitmq-plugins enable rabbitmq_management`：启用 RabbitMQ 的管理插件，这样您就可以通过 Web 界面访问 RabbitMQ。

### 4. 执行脚本

在 CentOS 系统中，将以上脚本保存为 `start-rabbitmq.sh` 文件，然后赋予执行权限并执行：

```bash
chmod +x start-rabbitmq.sh
./start-rabbitmq.sh
```

这将启动 RabbitMQ 容器并启用管理插件。

## 三、访问 RabbitMQ Web 管理界面

1. **访问 Web UI**

在浏览器中访问 RabbitMQ 的管理界面：

```
http://<your-server-ip>:15672
```

输入您在脚本中设置的用户名和密码（默认是 `username` 和 `password`），就可以登录到 RabbitMQ 的 Web 管理界面。

2. **常见的管理功能**

- **虚拟主机**：RabbitMQ 使用虚拟主机来隔离不同的消息队列，可以在 Web UI 中创建和管理虚拟主机。
- **队列**：管理消息队列，您可以查看队列中的消息数量、消费者数量等。
- **交换机**：管理交换机，并与队列进行绑定。
- **用户管理**：管理 RabbitMQ 用户和权限。

## 四、管理 RabbitMQ 容器

您可以通过以下命令管理 RabbitMQ 容器：

- **停止 RabbitMQ 容器**

```bash
sudo docker stop rabbitmq
```

- **启动 RabbitMQ 容器**

```bash
sudo docker start rabbitmq
```

- **重启 RabbitMQ 容器**

```bash
sudo docker restart rabbitmq
```

- **删除 RabbitMQ 容器**

```bash
sudo docker stop rabbitmq
sudo docker rm rabbitmq
```

- **查看 RabbitMQ 容器状态**

```bash
sudo docker ps
```

## 五、总结

通过 Docker 部署 RabbitMQ 是一种高效、简便的方式。通过上述步骤，您可以快速启动一个具有 Web 管理界面的 RabbitMQ 实例，并使用默认的用户名和密码进行访问。这个过程不仅简化了 RabbitMQ 的安装和配置，还确保了容器能够在系统重启后自动重启。

您可以根据需要定制 RabbitMQ 配置，添加更多的虚拟主机、队列、交换机以及权限设置，来满足生产环境的需求。

希望本教程对您有所帮助！

使用 Docker 安装和使用 RabbitMQ

# 使用 Docker 脚本部署 Jenkins

## 一、前置条件

1. **CentOS 7 或更高版本**：确保操作系统为 CentOS。
2. **已安装 Docker**：确认系统已经安装并启动 Docker。

## 二、准备工作

1. **文件夹授权**

在执行部署脚本之前，您需要为 Jenkins 的 `jenkins_home` 文件夹授予适当的权限。这样可以确保 Jenkins 运行时能正确访问存储和配置文件。



```bash
chmod -R 755 /data/jenkins
```

2. **权限设置**

接下来，您需要将文件夹权限设置为用户 `1000`，这是 Jenkins 默认的用户 ID。

```bash
chown -R 1000:1000 /data/jenkins/jenkins_home
```

## 三、部署 Jenkins 脚本说明

接下来是一个完整的 Bash 脚本，用于通过 Docker 部署 Jenkins，并配置 JDK、Maven、Gradle、Node.js 等开发工具。脚本中还包含一些自定义设置，如修改 Jenkins 插件更新源等。

### 部署脚本

```bash
#!/bin/bash
# docker部署启动jenkins脚本
############################################################
# 执行脚本前的前置操作
# 1、文件夹授权
# chmod -R 755 /data/jenkins
# 2、文件夹权限授权到用户1000
# chown -R 1000:1000 /data/jenkins/jenkins_home
############################################################
# 创建文件夹，如果存在则略过
curr_dir=$(pwd)
 # 初始化秒计数器
SECONDS=0
mkdir -p $curr_dir/jenkins_home
# 授权用户
chown -R 1000:1000 $curr_dir/jenkins_home
# 停止旧容器运行
docker stop jenkins
# 删除旧容器
docker rm jenkins
# 删除旧镜像
docker rmi jenkins/jenkins:jdk21
# 运行新的容器
docker run -itd \
--privileged=true \
--restart=always \
--name jenkins \
-p 28080:8080 \
-p 50000:50000 \
-v /data/java/jdk-11.0.17:/data/java/jdk-11.0.17 \
-v /data/java/jdk-17.0.7:/data/java/jdk-17.0.7 \
-v /data/maven/apache-maven-3.8.6:/data/maven/apache-maven-3.8.6 \
-v /data/gradle/gradle-8.5:/data/gradle/gradle-8.5 \
-v /data/nodejs/node-v16.18.1-linux-x64:/data/nodejs/node-v16.18.1-linux-x64 \
-v $curr_dir/jenkins_home:/var/jenkins_home \
-e JAVA_OPTS="-Xms2048m -Xmx2048m -Duser.timezone=Asia/Shanghai" \
jenkins/jenkins:jdk21

# 检查文件是否存在，如果不存在则等待
while [ ! -f "$curr_dir/jenkins_home/hudson.model.UpdateCenter.xml" ]
do
  echo -n '.'  # 每秒输出一个点
  sleep 1  # 每秒检查一次
done

echo
echo "耗时: $SECONDS 秒"

# 使用sed命令修改文件中的URL
sed -i 's|<url>.*</url>|<url>https://mirrors.tuna.tsinghua.edu.cn/jenkins/updates/update-center.json</url>|' $curr_dir/jenkins_home/hudson.model.UpdateCenter.xml

# 重启 Jenkins 容器
docker restart jenkins

exit 0
```

### 脚本解析

1. **创建工作目录和文件夹授权**
   - `mkdir -p $curr_dir/jenkins_home`：在当前目录下创建 Jenkins 配置存储文件夹 `jenkins_home`，如果该文件夹已存在，则不再创建。
   - `chown -R 1000:1000 $curr_dir/jenkins_home`：将该文件夹的权限设置为 Jenkins 默认用户 ID `1000`。

2. **停止并删除旧的 Jenkins 容器**
   - `docker stop jenkins`：停止已存在的 Jenkins 容器。
   - `docker rm jenkins`：删除已停止的 Jenkins 容器。
   - `docker rmi jenkins/jenkins:jdk21`：删除已存在的 Jenkins 镜像。

3. **拉取并运行新的 Jenkins 容器**
   - `docker run` 命令使用了以下选项：
     - `--privileged=true`：授予容器特权，允许容器执行一些受限制的操作。
     - `--restart=always`：设置容器自动重启策略，确保 Jenkins 在容器崩溃或服务器重启后继续运行。
     - `-p 28080:8080`：将宿主机的端口 `28080` 映射到容器的 Jenkins Web 界面端口 `8080`。
     - `-p 50000:50000`：用于 Jenkins 主机与代理之间的通信。
     - `-v`：映射宿主机的目录到容器中，以便持久化 Jenkins 配置和相关工具，如 JDK、Maven、Gradle 和 Node.js。
     - `-e JAVA_OPTS`：设置 Java 参数，指定内存限制和时区设置。

4. **等待文件生成并修改更新源**
   - 使用 `while` 循环等待 Jenkins 完成初始化，并确认 `hudson.model.UpdateCenter.xml` 文件已经生成。
   - 通过 `sed` 命令修改 `UpdateCenter.xml` 文件中的更新源 URL，将其更改为清华大学镜像源，以加快插件更新速度。

5. **重启 Jenkins 容器**
   - `docker restart jenkins`：重启 Jenkins 容器，应用更新的配置。

## 四、执行脚本

确保您已经按照步骤准备好必要的文件夹权限，并且已经安装了 Docker。然后，您可以执行脚本来部署 Jenkins：

```bash
chmod +x deploy-jenkins.sh
./deploy-jenkins.sh
```

该脚本将自动部署 Jenkins，并完成初始化设置。执行时会输出部署过程的时间和日志，您可以根据需要进行调试。

## 五、访问 Jenkins

完成部署后，您可以通过以下地址访问 Jenkins Web 界面：

```
http://<your-server-ip>:28080
```

首次访问时，输入上面脚本中获取的初始管理员密码，配置并安装推荐插件，创建管理员账号，完成 Jenkins 的配置。

## 六、常用插件
- Maven Integration —— 简化maven项目部署
- Gradle —— 简化gradle项目部署
- NodeJS —— 简化node项目部署
- WXWork Notification Plugin —— 企业微信通知
- DingTalk —— 钉钉通知
- Publish Over SSH —— 远程访问

## 七、总结

通过这个 Bash 脚本，您可以自动化部署 Jenkins，减少手动配置的复杂度。脚本中包括了 Docker 部署 Jenkins 所需的所有步骤，确保您能够快速启动并运行 Jenkins 环境。同时，脚本中也针对国内用户优化了插件更新源，使用清华大学镜像加速 Jenkins 插件的下载速度。

希望这个教程对您有所帮助！

jenkins安装使用教程

### [官网地址](https://github.com/Elegycloud/clash-for-linux-backup)

# 使用教程
首先申请一个代理地址，下面就以Ghelper为例：
![image.png](/static/img/e322eb7a2d3470e2209bf7f6d218345d.image.webp)
## 下载项目

下载项目

```bash
$ git clone https://github.com/Elegycloud/clash-for-linux-backup.git
```

进入到项目目录，编辑`.env`文件，修改变量`CLASH_URL`的值。

```bash
$ cd clash-for-linux
$ vim .env
```

> **注意：** `.env` 文件中的变量 `CLASH_SECRET` 为自定义 Clash Secret，值为空时，脚本将自动生成随机字符串。




## 启动程序

直接运行脚本文件`start.sh`

- 进入项目目录

```bash
$ cd clash-for-linux
```

- 运行启动脚本

```bash
$ sudo bash start.sh

正在检测订阅地址...
Clash订阅地址可访问！                                      [  OK  ]

正在下载Clash配置文件...
配置文件config.yaml下载成功！                              [  OK  ]

正在启动Clash服务...
服务启动成功！                                             [  OK  ]

Clash Dashboard 访问地址：http://<ip>:9090/ui
Secret：xxxxxxxxxxxxx

请执行以下命令加载环境变量: source /etc/profile.d/clash.sh

请执行以下命令开启系统代理: proxy_on

若要临时关闭系统代理，请执行: proxy_off

```

```bash
$ source /etc/profile.d/clash.sh
$ proxy_on
```

- 检查服务端口

```bash
$ netstat -tln | grep -E '9090|789.'
tcp        0      0 127.0.0.1:9090          0.0.0.0:*               LISTEN     
tcp6       0      0 :::7890                 :::*                    LISTEN     
tcp6       0      0 :::7891                 :::*                    LISTEN     
tcp6       0      0 :::7892                 :::*                    LISTEN
```

- 检查环境变量

```bash
$ env | grep -E 'http_proxy|https_proxy'
http_proxy=http://127.0.0.1:7890
https_proxy=http://127.0.0.1:7890
```

以上步鄹如果正常，说明服务clash程序启动成功，现在就可以体验高速下载github资源了。

<br>

## 重启程序

如果需要对Clash配置进行修改，请修改 `conf/config.yaml` 文件。然后运行 `restart.sh` 脚本进行重启。

> **注意：**
> 重启脚本 `restart.sh` 不会更新订阅信息。

<br>

## 停止程序

- 进入项目目录

```bash
$ cd clash-for-linux
```

- 关闭服务

```bash
$ sudo bash shutdown.sh
```

服务关闭成功，请执行以下命令关闭系统代理：proxy_off

```bash
$ proxy_off
```

然后检查程序端口、进程以及环境变量`http_proxy|https_proxy`，若都没则说明服务正常关闭。


<br>

## Clash Dashboard

- 访问 Clash Dashboard

通过浏览器访问 `start.sh` 执行成功后输出的地址，例如：http://192.168.0.1:9090/ui

- 登录管理界面

在`API Base URL`一栏中输入：http://\<ip\>:9090 ，在`Secret(optional)`一栏中输入启动成功后输出的Secret。

点击Add并选择刚刚输入的管理界面地址，之后便可在浏览器上进行一些配置。

- 更多教程

此 Clash Dashboard 使用的是[yacd](https://github.com/haishanh/yacd)项目，详细使用方法请移步到yacd上查询。