在 CentOS 上安装 MongoDB

一、安装 MongoDB 社区版

使用 yum 包管理器安装 MongoDB。

  1. 为 MongoDB 创建 /etc/yum.repos.d/mongodb-org-4.4.repo 文件。
    # nano /etc/yum.repos.d/mongodb-org-4.4.repo
  2. 将以下内容粘贴到编辑器中:
    [mongodb-org-4.4]
    
    name=MongoDB Repository
    
    baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/4.4/x86_64/
    
    gpgcheck=1
    
    enabled=1
    
    gpgkey=https://www.mongodb.org/static/pgp/server-4.4.asc
  3. 保存并退出文件。
  4. 要安装 MongoDB 的最新稳定版本,请执行以下操作:
    # sudo yum install -y mongodb-org

如果您需要安装特定版本或阻止自动升级。

二、设置 MongoDB

  1. 启动MongoDB。
    # systemctl start mongod.service
    
    # systemctl enable mongod.service
  2. 连接到MongoDB。
    # mongo

 三、后续步骤

默认情况下,MongoDB 并不安全。使用我们的指南来配置 MongoDB 安全性和身份验证。

注意:可以安全地忽略与 相关的任何启动警告。要防止出现这些警告,请通过运行 来验证扇区是否“如警告中所述”。如果输出大于 512,请运行以下命令:Readaheadblockdev –getra /dev/vda1

blockdev --setra 512 /dev/vda1

systemctl restart mongod

现在将解决该警告。

将 MongoDB 与 Node.js 一起使用

一、介绍

MongoDB 是一个 NoSQL数据库,将数据存储在由字段值对组成的文档中。这些是使用 BSON(JSON 的二进制表示形式)存储的。MongoDB 文档类似于关系数据库表中的行,文档字段(键值对)类似于列。MongoDB 文档是集合的一部分,一个或多个集合数据库的一部分。MongoDB API支持常规 CRUD 操作(创建,读取,更新,删除)以及聚合,地理空间查询和文本搜索功能。MongoDB 还提供高可用性和复制。您可以在多个MongoDB 服务器(称为副本集)之间分发数据,以提供冗余和分片。

本文将通过一个完整的示例引导您了解如何在 Docker 中设置 MongoDB 副本集、部署客户端应用程序以及探索更改流。它将涵盖以下内容:

  • MongoDB 和更改流的概述。
  • 如何使用 MongoDB Go 驱动程序。
  • 应用程序设置和部署
  • 测试应用程序并了解如何使用恢复令牌。

MongoDB 为许多客户端驱动程序提供官方支持,包括 Java,Python,Node.js,PHP,Ruby,Swift,C,C++,C# 和 Go。在本文中,您将使用 MongoDB 的 Go 驱动程序来构建更改流处理器和 REST API 应用程序。

1.1、MongoDB 更改流

使用更改流,您可以实时访问MongoDB数据更新。应用程序不需要担心处理 oplog 和更改流的低级操作细节。可以订阅集合、数据库或整个部署上的所有数据更改。由于更改流使用聚合框架,因此应用程序还可以筛选特定更改或转换通知。可以将更改流用于副本集(这是本文将使用的内容)和分片设置。

更改流仅在更新操作期间返回字段的差异(这是默认行为)。但您可以将其配置为返回更新文档的最新提交版本。还可以提供一个或多个管道阶段的数组来控制更改流输出。例如 -、、 等。$addFields$match$project

1.2、恢复令牌

恢复令牌允许应用程序保存进度并防止潜在的数据丢失。如果更改流应用程序崩溃,它将无法在此期间检测到数据库更改。恢复令牌可用于从应用程序停止的位置(崩溃之前)继续处理并接收所有过去的事件。更改流可以帮助构建分离且可缩放的体系结构,并使实现提取-转换-加载 (ETL)、通知、同步服务等变得更加容易。

二、应用概述

本文演示了以下应用程序:

  1. 更改流侦听器:它使用监视 API 订阅 MongoDB 集合的更改事件流。创建或更新文档后,此应用程序将立即收到实时通知。它还利用恢复令牌在重新启动或崩溃后从特定时间点继续处理。
  2. REST API:它公开了一个HTTP端点,以便在MongoDB中创建文档。

三、准备工作

  1. 使用本地 Linux 工作站,或将 Vultr 云服务器部署为工作站。
  2. 确保 Docker 已安装在工作站上。您将需要它来构建和运行 Docker 映像。
  3. 在工作站上安装 curl,一个流行的命令行 HTTP 客户端。
  4. 在工作站上安装最新版本的 Go 编程语言(版本 1.18 或更高版本)。

四、准备 MongoDB 更改流应用程序

4.1、初始化项目

创建一个目录并切换到该目录:

mkdir mongo-change-streams

cd mongo-change-streams

创建一个新的 Go 模块:

go mod init mongo-change-streams

这将创建一个新文件go.mod

创建一个新文件:main.go

touch main.go

4.2、导入库

要导入所需的 Go 模块,请将以下内容添加到文件中:main.go

package main



import (

  "context"

  "fmt"

  "log"

  "os"

  "os/signal"

  "syscall"

  "time"



  "go.mongodb.org/mongo-driver/bson"

  "go.mongodb.org/mongo-driver/mongo"

  "go.mongodb.org/mongo-driver/mongo/options"

)

除了 Go 标准库包之外,您还将从 MongoDB Go 驱动程序导入以下包:

  • go.mongodb.org/mongo-driver/mongo– 提供核心的MongoDB功能。
  • go.mongodb.org/mongo-driver/bson– 包 bson 是一个用于读取、写入和操作 BSON 的库。
  • go.mongodb.org/mongo-driver/mongo/options– 包选项定义了MongoDB Go驱动程序的可选配置。

4.3、添加函数init

将以下代码添加到文件中:main.go

var mongoConnectString string

var mongoDatabase string

var mongoCollection string

const msgFormat = "export RESUME_TOKEN=%s"



func init() {

  mongoConnectString = os.Getenv("MONGODB_URI")

  if mongoConnectString == "" {

    log.Fatal("missing environment variable", "MONGODB_URI")

  }



  mongoDatabase = os.Getenv("MONGODB_DATABASE")

  if mongoDatabase == "" {

    log.Fatal("missing environment variable", "MONGODB_DATABASE")

  }



  mongoCollection = os.Getenv("MONGODB_COLLECTION")

  if mongoCollection == "" {

    log.Fatal("missing environment variable", "MONGODB_COLLECTION")

  }

}

该函数分别从 、 和环境变量中检索 MongoDB 连接字符串、集合名称和数据库名称。initMONGODB_URIMONGODB_COLLECTIONMONGODB_DATABASE

4.4、添加函数main

将函数添加到文件:mainmain.go

func main() {

  client, err := mongo.NewClient(options.Client().ApplyURI(mongoConnectString))

  if err != nil {

    log.Fatal("failed to create mongo client", err)

  }



  fmt.Println("created client object")



  ctx, cancel := context.WithCancel(context.Background())



  err = client.Connect(ctx)

  if err != nil {

    log.Fatal("failed to connect to mongo", err)

  }



  fmt.Println("connected to mongodb")



  coll := client.Database(mongoDatabase).Collection(mongoCollection)



  defer func() {

    err = client.Disconnect(context.Background())

    if err != nil {

      fmt.Println("failed to close mongo connection")

    }

  }()



  match := bson.D{{"$match", bson.D{{"operationType", bson.D{{"$in", bson.A{"insert", "update", "replace" }}}}}}}

  project := bson.D{{"$project", bson.M{"_id": 1, "fullDocument": 1, "ns": 1, "documentKey": 1}}}

  pipeline := mongo.Pipeline{match, project}



  opts := options.ChangeStream().SetFullDocument(options.UpdateLookup)



  tokenFromEnv := os.Getenv("RESUME_TOKEN")



  if tokenFromEnv != "" {

    fmt.Println("resume token in enviroment variable", tokenFromEnv)



    t := bson.M{"_data": tokenFromEnv}

    opts.SetResumeAfter(t)



    fmt.Println("set resume token to watch client")

  }



  cs, err := coll.Watch(ctx, pipeline, opts)

  if err != nil {

    log.Fatal("failed to start change stream watch: ", err)

  }



  fmt.Println("watch established")



  defer func() {

    fmt.Println("resume token ", cs.ResumeToken().String())

    fmt.Println("use resume token in the next run with following command -", fmt.Sprintf(msgFormat, cs.ResumeToken().Lookup("_data").StringValue()))



    close, cancel := context.WithTimeout(context.Background(), 5*time.Second)

    defer cancel()



    err := cs.Close(close)

    if err != nil {

      fmt.Println("failed to close change stream")

    }



    fmt.Println("closed change stream")

  }()



  go func() {

    fmt.Println("started change stream...")



    for cs.Next(ctx) {

      re := cs.Current.Index(1)

      fmt.Println("change stream event" + re.Value().String())

    }

  }()



  exit := make(chan os.Signal, 1)

  signal.Notify(exit, syscall.SIGINT, syscall.SIGTERM)



  fmt.Println("waiting for program exit signal")



  <-exit

  fmt.Println("program exit initiated")

  cancel()

}
  • 用于创建新对象。mongo.NewClient*mongo.Client
  • 使用Connect启动与MongoDB的连接。
  • 调用数据库以获取 ,然后调用集合以获取 的句柄。mongo.Databasemongo.Collection
  • 延迟函数用于在程序结束时断开和关闭对象。*mongo.Client
  • A 是使用匹配项目阶段创建的。mongo.Pipeline
  • 如果使用环境变量提供恢复令牌,则用于配置更改流监视客户端。RESUME_TOKEN
  • 获取使用手表。作为程序退出过程的一部分,另一个 defer 函数用于提供恢复令牌信息并关闭更改流。mongo.ChangeStream
  • 更改流侦听器作为 goroutine 启动。它使用 Next 侦听更改流事件,用于获取文档,并将事件记录到控制台。Current.Index
  • 最后,设置一个 Go 通道,以便在程序中断时收到通知并干净地退出。

五、准备 MongoDB REST API 应用程序

创建一个新文件:api.go

touch api.go

5.1、导入库

要导入所需的 Go 模块,请将以下内容添加到文件中:api.go

package main



import (

  "context"

  "fmt"

  "log"

  "net/http"

  "os"

  "strconv"

  "time"



  "go.mongodb.org/mongo-driver/mongo"

  "go.mongodb.org/mongo-driver/mongo/options"

)

除了 Go 标准库包之外,我们还从 MongoDB Go 驱动程序导入以下包:

  • go.mongodb.org/mongo-driver/mongo– 提供核心的MongoDB功能。
  • go.mongodb.org/mongo-driver/mongo/options– 包选项定义了MongoDB Go驱动程序的可选配置。

5.2、添加函数init

将以下代码添加到文件中:api.go

var coll *mongo.Collection

var mongoConnectString string

var mongoDatabase string

var mongoCollection string



func init() {

  mongoConnectString = os.Getenv("MONGODB_URI")

  if mongoConnectString == "" {

    log.Fatal("missing environment variable", "MONGODB_URI")

  }



  mongoDatabase = os.Getenv("MONGODB_DATABASE")

  if mongoDatabase == "" {

    log.Fatal("missing environment variable", "MONGODB_DATABASE")

  }



  mongoCollection = os.Getenv("MONGODB_COLLECTION")

  if mongoCollection == "" {

    log.Fatal("missing environment variable", "MONGODB_COLLECTION")

  }



  client, err := mongo.NewClient(options.Client().ApplyURI(mongoConnectString))

  if err != nil {

    log.Fatal("failed to create mongo client", err)

  }



  fmt.Println("created mongo client object")



  err = client.Connect(context.Background())

  if err != nil {

    log.Fatal("failed to connect to mongo", err)

  }



  fmt.Println("connected to mongo")



  coll = client.Database(mongoDatabase).Collection(mongoCollection)

}

该函数分别从 、 和环境变量中检索 MongoDB 连接字符串、集合名称和数据库名称。它调用数据库方法来获取 ,然后调用集合以获取 .initMONGODB_URIMONGODB_COLLECTIONMONGODB_DATABASEmongo.Databasemongo.Collection

5.3、添加函数main

将函数添加到文件:mainapi.go

func main() {

  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {



    res, err := coll.InsertOne(context.Background(), map[string]string{"user": "user-" + strconv.Itoa(int(time.Now().Unix()))})

    if err != nil {

      log.Fatal("mongo insert failed", err)

    }



    fmt.Println("created record", res.InsertedID)

  })



  fmt.Println("started http server...")

  log.Fatal(http.ListenAndServe(":8080", nil))

}

main 函数注册一个 HTTP 处理程序,以便在调用时将记录插入到 MongoDB 集合中。HTTP 服务器在端口 8080 上启动。

六、准备 Docker 映像

6.1、添加 Docker 文件

创建一个名为 的文件:Dockerfile.change_stream_app

touch Dockerfile.change_stream_app

在 中输入以下内容:Dockerfile.change_stream_app

FROM golang:1.18-buster AS build



WORKDIR /app

COPY go.mod ./

COPY go.sum ./



RUN go mod download



COPY main.go ./

RUN go build -o /mongodb-app



FROM gcr.io/distroless/base-debian10

WORKDIR /

COPY --from=build /mongodb-app /mongodb-app

EXPOSE 8080

USER nonroot:nonroot

ENTRYPOINT ["/mongodb-app"]
  • 这是一个多阶段,用作第一阶段的基础映像。Dockerfilegolang:1.18-buster
  • 复制应用程序文件,运行 ,然后生成应用程序二进制文件。go mod download
  • 在第二阶段,用作基础映像。gcr.io/distroless/base-debian10
  • 从第一阶段复制二进制文件,并将其配置为运行应用程序。ENTRYPOINT

创建一个名为 的文件:Dockerfile.rest_api

touch Dockerfile.rest_api

在 中输入以下内容:Dockerfile.rest_api

FROM golang:1.18-buster AS build



WORKDIR /app

COPY go.mod ./

COPY go.sum ./



RUN go mod download



COPY api.go ./

RUN go build -o /mongodb-api



FROM gcr.io/distroless/base-debian10

WORKDIR /

COPY --from=build /mongodb-api /mongodb-api

EXPOSE 8080

USER nonroot:nonroot

ENTRYPOINT ["/mongodb-api"]
  • 这是一个多阶段,用作第一阶段的基础映像。Dockerfilegolang:1.18-buster
  • 复制应用程序文件,运行 ,然后生成应用程序二进制文件。go mod download
  • 在第二阶段,用作基础映像。gcr.io/distroless/base-debian10
  • 从第一阶段复制二进制文件,并将其配置为运行应用程序。ENTRYPOINT

6.2、构建 Docker 镜像

拉动模块:

go mod tidy

为更改流应用程序构建 Docker 映像:

docker build -t mongo-change-streams -f Dockerfile.change_stream_app .

为 REST API 应用程序构建 Docker 镜像:

docker build -t mongo-rest-api -f Dockerfile.rest_api .

 七、在 Docker 中启动 MongoDB 集群

创建一个 Docker 网络:

docker network create mongodb-cluster

启动第一个节点 mongo1

docker run -d --rm -p 27017:27017 --name mongo1 --network mongodb-cluster mongo mongod --replSet myReplicaSet --bind_ip localhost,mongo1

启动第二个节点 mongo2

docker run -d --rm -p 27018:27017 --name mongo2 --network mongodb-cluster mongo mongod --replSet myReplicaSet --bind_ip localhost,mongo2

启动第三个节点 mongo3

docker run -d --rm -p 27019:27017 --name mongo3 --network mongodb-cluster mongo mongod --replSet myReplicaSet --bind_ip localhost,mongo3

配置副本集:

docker exec -it mongo1 mongosh --eval "rs.initiate({

_id: \"myReplicaSet\",

members: [

  {_id: 0, host: \"mongo1\"},

  {_id: 1, host: \"mongo2\"},

  {_id: 2, host: \"mongo3\"}

]

})"

您应该看到以下输出:

{ ok: 1 }

 八、启动两个应用程序

在终端中,启动更改流应用程序:

export MONGODB_URI=mongodb://mongo1:27017,mongo2:27017,mongo3:27017/?replicaSet=myReplicaSet



docker run --network mongodb-cluster -e MONGODB_URI=$MONGODB_URI -e MONGODB_DATABASE=test_db -e MONGODB_COLLECTION=test_collection -e RESUME_TOKEN=$RESUME_TOKEN mongo-change-streams

您将看到类似于以下内容的输出:

created client object

connected to mongodb

watch established

started change stream...

waiting for program exit signal

在另一个终端中,启动 REST API 应用程序:

export MONGODB_URI=mongodb://mongo1:27017,mongo2:27017,mongo3:27017/?replicaSet=myReplicaSet



docker run --network mongodb-cluster -p 8080:8080 -e MONGODB_URI=$MONGODB_URI -e MONGODB_DATABASE=test_db -e MONGODB_COLLECTION=test_collection mongo-rest-api

您将看到类似于以下内容的输出:

created mongo client object

connected to mongo

started http server...

 九、测试应用程序

在MongoDB中创建一些记录。为此,调用 REST API 应用程序(从另一个终端)公开的 HTTP 端点:

curl -i localhost:8080

重复上述过程两到三次。在所有情况下,您都应该得到HTTP / 1.1 200 OK响应。

导航到终端并检查 REST API 应用程序日志。您应该会看到已创建的记录。请注意,在您的情况下,对象 ID 可能有所不同:

created record ObjectID("639c092160078afff212209b")

created record ObjectID("639c097660078afff212209c")

created record ObjectID("639c097760078afff212209d")

导航到终端并检查更改流应用程序日志。您应该看到与上述相同的记录(由 REST API 应用程序创建)。这些是由更改流侦听器进程自动检测到的。请注意,在您的情况下,对象 ID 可能有所不同:

change stream event{"_id": {"$oid":"639c092160078afff212209b"},"user": "user-1671170337"}

change stream event{"_id": {"$oid":"639c097660078afff212209c"},"user": "user-1671170422"}

change stream event{"_id": {"$oid":"639c097760078afff212209d"},"user": "user-1671170423"}

9.1、使用更改流恢复令牌

首先,关闭更改流应用程序 – 在运行该应用程序的相应终端上按 +。CTRLC

您应该会看到与此类似的日志。请注意,令牌可能因您的情况而异。

resume token  {"_data": "82639C09A4000000012B0229296E04"}

use this token in the next run with following command - export RESUME_TOKEN=82639C09A4000000012B0229296E04

日志消息突出显示了如果要利用 Resume 令牌时应使用的命令。记下该命令。

通过调用 REST API 应用程序公开的 HTTP 端点向 MongoDB 添加一些记录:

curl -i localhost:8080

重复几次。

导航到终端并检查 REST API 应用程序日志。您应该会看到已创建的记录。请注意,在您的情况下,对象 ID 可能有所不同:

created record ObjectID("639c09ed60078afff212209e")

created record ObjectID("639c09ee60078afff212209f")

重新启动更改流应用程序。这一次,通过将 Resume 令牌作为环境变量传递来使用它。您可以使用上面的日志输出中的命令:

export RESUME_TOKEN=82639C09A4000000012B0229296E04



export MONGODB_URI=mongodb://mongo1:27017,mongo2:27017,mongo3:27017/?replicaSet=myReplicaSet



docker run --network mongodb-cluster -e MONGODB_URI=$MONGODB_URI -e MONGODB_DATABASE=test_db -e MONGODB_COLLECTION=test_collection -e RESUME_TOKEN=$RESUME_TOKEN mongo-change-streams

您应该会看到与此类似的日志。请注意,令牌和对象 ID 在您的情况下可能会有所不同。

token passed in as enviroment variable 82639C09A4000000012B0229296E04

set token to watch client option

watch established

started change stream...

change stream event{"_id": {"$oid":"639c09ed60078afff212209e"},"user": "user-1671170541"}

change stream event{"_id": {"$oid":"639c09ee60078afff212209f"},"user": "user-1671170542"}

验证您收到的记录是否与关闭更改流应用程序时添加的记录相同。

您可以通过调用 REST API 应用程序公开的 HTTP 端点来继续向 MongoDB 添加记录:

curl -i localhost:8080

正如预期的那样,更改流应用程序将实时检测和记录这些:

您应该看到类似于以下内容的日志:

change stream event{"_id": {"$oid":"639c0a5c60078afff21220a0"},"user": "user-1671170652"}

change stream event{"_id": {"$oid":"639c0a5d60078afff21220a1"},"user": "user-1671170653"}

 十、收尾

最后,要停止这两个应用程序,请在各自的终端中按 +。CTRLC

同时删除 MongoDB 集群实例和 Docker 网络:

docker rm -f mongo1 mongo2 mongo3

docker network rm mongodb-cluster

 十一、结论

在本文中,您将了解 MongoDB 和更改流的概述。您在 Docker 中设置了一个 MongoDB 副本集,部署了客户端应用程序,并通过端到端示例探索了更改流和恢复令牌。

如何创建 MongoDB 副本集

一.介绍

在任务关键型应用程序中部署 MongoDB 数据库时,可以配置副本集以实现高可用性。副本集提供冗余和高可用性,由于没有单点故障,因此可减少灾难期间的停机时间。MongoDB 副本集的最低建议配置是一个主节点和两个辅助节点,但副本集最多可以有 50 个成员。应用程序仅写入主节点,辅助节点复制数据。如果主节点发生故障,副本集将举行选举以选择新的主节点。应用程序可以从辅助数据库读取数据,但不能写入它们。

本指南介绍如何创建 MongoDB 副本集。它在 Ubuntu 20.04 上进行了测试,但其他 Linux 发行版的步骤类似。

二.准备工作

您需要将三台服务器连接到同一个 Vultr VPC。每个服务器都应具有:

  • 配置了 sudo 权限的非 root 用户
  • MongoDB安装并使用密码保护
  • 为清楚起见,本指南对服务器使用以下主机名和专用 IP 地址。您应该用您的值替换这些值。
    • 主:服务器-1 – 10.0.0.1
    • 辅助:服务器-2 – 10.0.0.2
    • 辅助:服务器-3 – 10.0.0.3

三 配置主机文件

MongoDB建议使用DNS主机名而不是副本成员的IP地址。由于 Vultr VPC 是没有 DNS 的私有网络,因此请将私有 IP 地址和主机名添加到主机文件中。在每台服务器上重复这些步骤。

  1. 以非 root 用户身份通过 SSH 连接到服务器。
  2. 编辑主机文件。
    $ sudo nano /etc/hosts
  3. 找到下面的行。
    127.0.0.1 localhost
  4. 输入 IP 地址和主机名,如该行下所示。
    127.0.0.1 localhost
    10.0.0.1 server-1
    10.0.0.2 server-2
    10.0.0.3 server-3
  5. 保存并关闭文件。

四. 设置复制密钥

副本集中的所有服务器共享一个 base64 密钥。请按照以下步骤安装密钥。

使用该命令在其中一台服务器上生成新密钥。openssl

$ openssl rand -base64 756

你应该得到这样的块。复制此 base64 密钥。您将在以下步骤中使用它。

Yga80PbkHKptRRoONFCPaPzOCFpySgpwNHMA3JS179wyGCOIOYg/FUnDyiIhGe5D
YVQF3o+SliscBiKftsPZ5WBojRREcefAUHOqK7pVBOjT+oYuH6ltMGiDtH26XjVB
... truncated ...
yxJm+UjpN0n8V1pH1LrMJT4FC4Bw3L7vqSnxVbLRnQIiO2Y0ECfyPgepCCNIyuaP
mMSUJ8mmlq4jdfoAKvCspeliSQ/cqaxKfqaTWjzhsLk8eHbU

在每台服务器上重复这些步骤。

  1. 创建新的auth_key文件。
    $ sudo nano /var/lib/mongodb/auth_key
  2. 粘贴您的 base64 密钥。
  3. 保存并关闭文件。
  4. 将权限设置为 400,使文件对文件所有者只读,对所有其他文件都被拒绝访问。
    $ sudo chmod 400 /var/lib/mongodb/auth_key
  5. 将所有者和组更改为 mongodb
    $ sudo chown mongodb:mongodb /var/lib/mongodb/auth_key

 五. 配置 MongoDB

在本部分中,你将配置共享密钥、网络接口和副本集名称。在每台服务器上重复这些小节。

5.1. 配置共享密钥

  1. 在编辑器中打开 mongod.conf 以执行以下步骤。
    $ sudo nano /etc/mongod.conf
  2. 找到安全部分。
    security:
      authorization: enabled
    #operationProfiling:
  3. 授权:行下,添加键文件值,如下所示。
    security:
      authorization: enabled
      keyFile: /var/lib/mongodb/auth_key
    #operationProfiling:

5.2. 配置网络接口

  1. 找到网络接口部分。
    # network interfaces
    net:
      port: 27017
      bindIp: 127.0.0.1
  2. 将环路接口 (127.0.0.1) 之后的相应服务器名称添加到每个服务器。例如:在服务器 1 上:
    # network interfaces
    net:
      port: 27017
      bindIp: 127.0.0.1, server-1

    在服务器 2 上:

    # network interfaces
    net:
      port: 27017
      bindIp: 127.0.0.1, server-2

    在服务器 3 上:

    # network interfaces
    net:
      port: 27017
      bindIp: 127.0.0.1, server-3

5.3. 配置副本集名称

  1. 找到复制部分。
    #replication:
  2. 从复制行中删除注释。在此下方,按所示添加。#replSetName: "rs0"
    replication:
      replSetName: "rs0"
  3. 在主节点上重新启动 MongoDB。
    $ sudo systemctl restart mongod
  4. 在辅助节点上重新启动 MongoDB。
    $ sudo systemctl restart mongod

 六. 引导副本集

在本部分中,你将节点添加到副本集并引导复制过程。

  1. 在主节点上,登录到MongoDB。
    $ mongosh -u your_admin_name -p --authenticationDatabase admin
  2. 输入您的管理员帐户的密码,然后按继续。ENTER
  3. 运行以下命令以添加副本集成员。
    test> rs.initiate(
          {
          _id: "rs0",
          members: [
              { _id: 0, host: "server-1" },
              { _id: 1, host: "server-2" },
              { _id: 2, host: "server-3" }
              ]
          })
  4. 当副本集启动时,应收到以下响应。请注意,提示符更改为 。rs0 [direct: secondary] test>
    { ok: 1 }
    rs0 [direct: secondary] test>
  5. 创建示例company_db数据库。
    rs0 [direct: secondary] test> use company_db
  6. 您应该会收到以下响应,提示更改为 。此成员现在是主节点。rs0 [direct: primary] company_db>
    switched to db company_db
    rs0 [direct: primary] company_db>
  7. company_db数据库的新员工集合中插入示例记录。
    rs0 [direct: primary] company_db> db.employees.insertOne({   
                                      "staff_id" : 1,
                                      "staff_name" : "JOHN DOE",
                                      "phone" : "11111111"  
                                      })
  8. 您应该得到下面的输出。
    {
      acknowledged: true,
      insertedId: ObjectId("621dcf1abdb5b0c5e59294d9")
    }
  9. 在每个辅助节点上,登录到MongoDB。
    $ mongosh -u your_admin_name -p --authenticationDatabase admin
  10. 输入您的管理员帐户的密码,然后按继续。ENTER
  11. 您应该会看到下面的提示,显示成员是辅助节点。
    rs0 [direct: secondary] test>
  12. 在每个辅助节点上,切换到company_db
    rs0 [direct: secondary] test> use company_db
  13. 应得到以下输出。
    switched to db company_db
  14. 在每个辅助节点上运行以下命令,以允许它们接受读取命令。
    rs0 [direct: secondary] company_db> db.getMongo().setReadPref('primaryPreferred')
  15. 列出员工集合中的文档。
    rs0 [direct: secondary] company_db> db.employees.find()
  16. 您应该在每个辅助节点上获得以下输出,该输出显示副本集将数据复制到每个节点。
    [
      {
        _id: ObjectId("621dcf1abdb5b0c5e59294d9"),
        staff_id: 1,
        staff_name: 'JOHN DOE',
        phone: '11111111'
      }
    ]
  17. 尝试在任何辅助节点上添加新的员工记录。
    rs0 [direct: secondary] company_db> db.employees.insertOne({   
                                      "staff_id" : 2,
                                      "staff_name" : "MARY ROE",
                                      "phone" : "22222222"  
                                      })
  18. 该命令应失败。辅助节点是只读的。
    MongoServerError: not primary
  19. 如果停止主服务器或主服务器脱机,副本集将选择其中一个辅助节点作为新的主节点。
    $ sudo systemctl stop mongod

将分布式应用程序连接到数据库:优点和缺点

一、介绍

随着公司跨不同地理区域的发展,统一业务流程的一种方法是实现与中央数据库通信的分布式应用程序。但是,此方法要求您将应用程序分解为两个单独的程序:服务器软件和客户端软件。

服务器软件应驻留在安全的云环境中,例如 Vultr 的云计算、裸机或 Vultr Managed Kubernetes (VKE)。这通常称为后端。在面向数据的应用程序中,您的后端必须绑定到关系数据库服务器,例如 MySQL 或 PostgreSQL。基于云的数据库更具弹性、可扩展性,并且可以处理大型工作负载。

另一方面,客户端软件是在用户的计算机或移动设备上运行的前端。例如,手机上的Facebook应用程序是客户端应用程序。您可以使用任何现代编程语言设计前端应用程序,包括Java,C#,VB.Net,Swift,Android等。

设计分布式应用程序时出现的唯一主要挑战是将本地客户端应用程序(例如,移动应用程序和桌面应用程序)链接到服务器软件(在线数据库)的最佳方法。在本指南中,您将学习可以实施的两种不同方法以及每种方法的优缺点。

二、直接连接方式

每个新的云计算程序员在将应用程序的后端连接到云时都会想到一个简单的想法,那就是更改数据库连接字符串。例如,如果您在本地部署了连接到本地 MySQL 实例的应用程序,则数据库连接字符串可能类似于以下代码片段。

    Server=localhost;Database=sample_database;user=sample_user;password=EXAMPLE_PASSWORD;

现在,要将应用程序的数据库移动到云中,您只需启动云服务器,安装 MySQL 服务器并将连接字符串更改为以下设置,其中 是云服务器的域名。example.com

    Server=example.com;Database=sample_database;user=sample_user;password=EXAMPLE_PASSWORD;

上述方法应该可以很好地工作,并且您需要在客户端的应用程序中更改最少的代码。但是,它具有以下缺点,应不惜一切代价避免。

  1. 直接连接方法要求软件的每个副本都将数据库凭据硬编码在某处。即使您可能尝试加密连接字符串,单个安全漏洞或漏洞也会使您的应用程序毫无价值。如果黑客设法获取连接字符串,他们可以破解应用程序中的每个用户帐户,因为他们已经可以直接访问中央数据库。
  2. 由于不同地理区域中的用户可以访问分布式应用程序,因此直接连接方法要求您向每台主机打开数据库端口。这为机器人、DDoS 和暴力攻击创造了一个非常好的途径。
  3. 紧密耦合。由于已将连接字符串保存在分发的每个软件副本中,因此数据库凭据中的单个更改将意味着锁定所有用户。

从上述缺点可以看出,将分布式应用程序连接到云数据库的直接方法并不是最佳方法。在下一步中,您将看到一种更可靠且几乎防故障的方法。

三、接口连接方式

API 代表应用程序编程接口。这是一个中间件,允许您的前端应用程序以安全的方式与后端应用程序通信。

API 层应驻留在云基础架构中,例如 Vultr 的云计算实例或 VPS。基本上,以下是通过 API 将分布式应用程序迁移并连接到云数据库的基本过程。

  1. 注册一个云计算帐户。
  2. 然后,启动一个 Linux 服务器。例如,Ubuntu 20.04 对于云计算初学者来说是一个很好的操作系统。
  3. 接下来,在 Linux 服务器中安装数据库服务器。例如,您可以安装 MySQL 或部署 PostgreSQL 数据库服务器。
  4. 在服务器上创建新数据库,然后从本地数据库导入数据。
  5. 接下来,使用您喜欢的脚本语言(例如 PHP、Golang、Python 等)创建一个 API。请参阅以下指南,了解创建 API 的基础知识。
    • 在 Linux 上使用 Golang 和 MySQL 8 设计现代 API。
    • 在 Ubuntu 20.04 上使用 PHP 和 MySQL 创建一个 JSON REST API。
  6. 您的 API 应支持身份验证、授权、排序、筛选、分页和自定义字段选择。
  7. 然后,您应该将 API 源代码放在 Web 服务器的根目录中,以便可以通过 HTTP 方法(、、 和 )公开访问它。GETPOSTPUTDELETE
  8. 接下来,重新设计应用程序(例如,桌面软件或移动应用)以使用新的 API 终结点,而不是连接字符串。现代编程语言附带了不同的库,允许您使用最少的代码执行此操作。例如,当使用Android编写应用程序时,您可以使用Volley库。同样,对于 .NET 应用程序,可以使用 WebRequest 类向 API 终结点发出 HTTP 请求。
  9. 典型的 API 终结点类似于以下 URL。
    http://www.example.com/api/v1
  10. 最后,使用新的 API 设置发布应用。

API 连接方法可能需要更长的时间才能实现。此外,它还要求您完全重组前端应用程序。但是,它具有以下优点。

  1. 数据库凭据仅保存在 API 层中。最终用户在连接到云应用程序时应通过 HTTPS 使用其帐户凭据。这种方法更安全,如果发生中间人攻击,只有少数用户帐户受到威胁,而不是整个数据库。
  2. 松耦合。使用 API 方法时,应用程序有 3 层。即前端、中间件 (API) 和后端(数据库)。这意味着单个组件中的更改可能并不总是影响其他组件的存在。
  3. 代码重用。API 方法促进代码重用。多个客户端应用程序可以使用 API 数据。例如,您可以创建一个 API,将公司门户、移动应用程序、桌面应用程序、基于 Web 的软件等连接到中央数据库。这意味着您只需要维护一个 API 端点,这大大降低了编程成本和运行 IT 基础架构所需的员工数量。

三、结论

在权衡了这两种方法之后,很明显 API 方法胜出,并且始终是推荐的方法。此外,像 Facebook 和T witter 这样的大公司使用API 方法,因为它是高度安全的。

如果你的公司正在大幅增长到不同的地理区域,则应考虑在云中设计和托管分布式应用。最后,您将拥有一个更安全、更稳定的弹性系统,最重要的是,您将拥有一个用于所有业务流程的中央数据库。

如何在 CentOS 7 上安装 Apache CouchDB

一、介绍

Apache CouchDB是一个免费的开源NoSQL数据库服务器,它将数据库存储为JSON格式的文档。它包括一个 RESTful HTTP API,可让您轻松创建、读取、编辑和删除文档。

本指南将教你如何在 CentOS 7 服务器上安装和设置 Apache CouchDB。

1.1、准备工作

  • 部署 CentOS 7 Vultr 服务器。
  • 登录到服务器。
  • 更新服务器。

二、设置 CouchDB 存储库

安装 CentOS EPEL 資料庫。

$ sudo yum install epel-release

然后,设置一个新的 CouchDB 存储库文件:

$ sudo nano /etc/yum.repos.d/apache-couchdb.repo

将以下内容粘贴到其中:

[Apache-Couchdb]

name=couchdb

baseurl=https://apache.jfrog.io/artifactory/couchdb-rpm/el$releasever/$basearch/

gpgkey=https://couchdb.apache.org/repo/keys.asc https://couchdb.apache.org/repo/rpm-package-key.asc

gpgcheck=1

repo_gpgcheck=1

enabled=1

更新服务器。

$ sudo yum install couchdb

 三、安装 CouchDB

现在,所有必要的存储库都已设置完毕,请使用以下命令安装 CouchDB:

$ sudo yum install couchdb

启用 CouchDB 以在引导时启动。

$ sudo systemctl enable couchdb

启动 CouchDB。

$ sudo systemctl start couchdb

 四、设置 CouchDB

所有 CouchDB 数据和配置文件都存储在 中,并且是位于子目录中的主配置文件。首先,通过将 CouchDB 绑定到网络地址来设置 CouchDB,然后添加新的管理用户。/opt/couchdblocal.ini/etc/

打开文件 。/opt/couchdb/etc/local.ini

$ sudo nano /opt/couchdb/local.ini

找到条目 ,并将其更改为您的首选设置。默认情况下,它设置为 ,该地址使 CouchDB 可从任何网络地址访问,并将其绑定到您的公共 Vultr IP 地址。bind_address =127.0.0.10.0.0.0global

[chttpd]

;port = 5984

bind_address = 127.0.0.1

要设置新用户,请滚动到底部或搜索关键字。在该部分下,添加一个格式为 .要加强服务器安全性,请替换为您选择的秘密用户名。adminsusername = passwordadmin

[admins]

admin = YOUR-PASSWORD

此外,添加以下条目以允许 CouchDB 在重新启动时创建所有必要的系统数据库。

[couchdb]



single_node=true

保存并关闭文件。

或者,您可以使用以下命令手动创建系统数据库:、、:_users_replicator_global_changes

$ curl -u Username:Password -X PUT http://127.0.0.1:5984/_users

$ curl -u Username:Password -X PUT http://127.0.0.1:5984/_replicator

$ curl -u Username:Password -X PUT http://127.0.0.1:5984/_global_changes

重新启动 CouchDB 以使更改生效。

$ sudo systemctl restart couchdb

 4.1、配置防火墙

首先,允许服务器上的 HTTP 流量。

$ sudo firewall-cmd --permanent --zone=public --add-service=http

如果服务器上有 SSL 证书,请允许 HTTPS 流量。

$ sudo firewall-cmd --permanent --zone=public --add-service=https 

然后,打开端口 5984。

$ sudo firewall-cmd --permanent --zone=public --add-port=5984/tcp

重新启动防火墙以使规则生效。

$ sudo systemctl reload firewalld

4.2、测试您的 CouchDB 安装

在终端窗口中,使用以下 curl 命令测试 CouchDB 安装:

$ curl 127.0.0.1:5984

您的输出应类似于以下内容:

{"couchdb":"Welcome","version":"3.2.1","git_sha":"244d428af","uuid":"99b896bf19b5b076970e12574b9b9ff8","features":["access-ready","partitioned","pluggable-storage-engines","reshard","scheduler"],"vendor":{"name":"The Apache Software Foundation"}}

访问 Vultr 服务器的公共 IP 地址在端口上,并带有 GUI 版本的端点。5984/utils

http://SERVER-IP:5984/_utils

![CouchDB 登录页面(https://i.imgur.com/RF9K8D8.png)

使用之前创建的管理员用户名和密码登录以继续。

构建 Kubernetes:如何选择集群部署策略

一、介绍

本指南将引导您完成在为 Vultr Kubernetes 引擎 (VKE) 选择集群部署策略时应考虑的一些架构决策,以及每种方法的优缺点。

VKE 群集是一组服务器,它们为以高度可用、分布式和可扩展的方式运行应用程序和服务提供基础架构。集群由一个控制平面(负责管理集群)和一个或多个工作器节点(负责运行实际应用程序和服务)组成。控制平面提供核心调度、网络和存储服务。它管理基础结构,例如虚拟机和容器。它监督工作节点之间的通信,以确保它们以最佳方式运行。工作器节点负责运行托管群集各种工作负载的容器(称为 Pod)。

有多种方法可以配置群集体系结构以托管应用程序,这些方法具有灵活扩展、成本效率、应用程序和环境隔离、易于管理等优势。幸运的是,VKE 提供了一个免费的控制平面,并且只对工作节点的总数收费,这消除了为您的应用程序选择最佳架构时的任何成本考虑因素。但是,在选择部署策略时,除了成本之外,还应考虑其他重要事项。本指南探讨了每种方法最重要的优缺点,以帮助您做出明智的选择。

二、基于大小的架构模式

组织和分组群集的一种方法是按大小。Kubernetes 集群可以通过添加和删除工作器节点或部署具有不同计算资源量(如 CPU、内存和存储)的工作器节点来扩展或缩减。这些工作器节点是运行应用程序的物理或虚拟服务器。使用 VKE,您可以轻松添加或删除节点以调整集群大小。Kubernetes 集群非常强大和高效,允许用户根据自己的需求快速扩展或缩减其计算资源。

集群的大小是工作器节点总数及其每个计算资源的组合,它们用于部署更多 Pod(水平扩展)或为每个 Pod 分配不同数量的计算资源(垂直扩展)。

2.1、几个大型集群

在此架构配置中预置一些集群来托管工作负载。您甚至可以使用单个集群。每个都相对较大,有许多工作节点和计算资源可用于在许多 Pod 中运行工作负载。

使用几个大型集群有好处:

  • 您可以优化资源利用率。在几个大型集群上托管应用程序时,工作节点会有效地与 Pod 共享计算资源,从而最大限度地减少计算能力的浪费。
  • 您可以有效地管理基础架构,因为您无需与多个集互即可执行管理或日常任务。
  • 您可以重复使用集群范围的资源,例如负载均衡器、入口控制器等,从而使其管理更简单、更高效。一个

但是,拥有几个大型集群有一些缺点:

  • 如果需要分离不同的应用程序,单个控制平面只能具有软多租户。Kubernetes 命名空间和基于角色的访问控制提供租户之间的分离,但它们共享相同的控制平面组件,例如用于服务发现的 DNS 服务器。
  • 集群越少,容错能力就越低,因为每个集群上集中的服务就越多。任何服务中断或故障都可能导致大量容量丢失。
  • 如果大型群集发生故障,则重建该群集更具挑战性。大型群集可能具有各种不同的应用程序,这些应用程序需要复杂的配置过程。
  • 在单个群集上具有太多不同的租户应用程序可能会给控制平面组件带来压力,从而导致意外错误。如果计划托管许多应用程序,最好将它们分布在多个群集中。

2.2、许多小集群

在此体系结构模式中,您将工作负载分布在具有较小工作器节点的较大集群组中。这可实现灵活的扩展、成本效益、应用程序和环境隔离以及易于管理。如果集群过载,可以将某些 Pod 移动到另一个集群,使其成为更动态、更高效的解决方案。

如果需要,使用许多小型集群是很好的:

  • 硬多租户:您可以通过将应用程序分布在不同的集群中来完全隔离应用程序,以防止共享控制平面组件。
  • 容错:此体系结构具有更强的容错能力。在发生单个集群故障时,您可以保留大量容量。
  • 降低复杂性:重建损坏的小型群集不太复杂,因为它托管的应用程序较少。

此模式有一些缺点:

  • 您必须反复与许多不同的集互,以执行管理或例行任务,例如监视、更新等。
  • 将应用程序分散到许多不同的集群可能会浪费负载均衡器和入口控制器等资源,而这些资源可以同时处理许多应用程序。

三、基于效用的架构模式

应用程序可能包含前端、数据库、业务逻辑等的多个组件。您可能会发现自己需要部署应用程序的多个实例来创建不同的环境,例如生产、开发、测试、暂存等。这些环境中的每一个都可能具有非常不同的要求来满足应用程序的需求,这可能导致资源使用效率低下。

幸运的是,可以使用其他几种体系结构模式来解决此问题。这些关注的是 Kubernetes 集群的效用,而不是它的大小。例如,您可能会发现一个应用程序占用更多 CPU,而另一个应用程序需要大量内存。此外,生产环境可能需要入口控制器,而开发不需要,依此类推。通过选择正确的配置,您可以确保应用程序尽可能高效地运行,同时满足每个环境的需求。

3.1、每个应用程序的群集数

每个应用程序群集的方法在单个群集中运行每个应用程序及其所有环境(例如开发、测试和生产)。此体系结构配置提供了许多优点,例如应用程序隔离和易于管理,因为应用程序的所有相关组件都可以一起找到。此外,它还允许更大的可扩展性,因为可以配置集群以满足应用程序的确切要求,包括不同的计算资源和 Kubernetes 版本。

但是,由于所有环境都位于同一群集上,因此这可能会对性能和可靠性产生不利影响。假设在一个环境中出现问题,例如在测试环境中执行错误的代码。在这种情况下,它可能会导致其他环境(尤其是生产环境)的服务中断。因此,在同一群集上托管多个环境时,请务必采取额外的预防措施。

3.2、每个环境的群集数

每个环境群集的方法允许您在单个群集上托管共享环境(例如测试或生产)的多个应用程序。这种方法的好处是:

  • 高效使用资源:您可以根据环境要求预置每个集群的计算资源。您的开发和测试环境可能小于生产环境。
  • 访问隔离:更容易限制对生产群集或托管敏感环境的其他内容的访问。

但是,与每个应用程序群集的方法相比,管理单个应用程序更为复杂,因为您将环境分散在不同的群集上。可能有更好的方法来对具有高度可变要求的应用程序进行分组。例如,需要不同 Kubernetes 版本的应用程序不能使用这种方法组合在一起。

此外,使用此方法时,您必须管理多个群集及其资源,这可能会成为一项艰巨的任务。这是因为必须单独预配和维护每个群集,并且必须跨所有群集复制对应用程序或环境所做的任何更改。此外,如果一个集群关闭,可能会影响其他集群及其应用程序,从而导致潜在的停机。

幸运的是,有一些方法可以最大程度地降低此方法的复杂性。例如,您可以使用自动化工具来管理集群和资源,从而简化管理多个集群的过程。此外,您可以使用容器化技术来确保应用程序和环境可以在多个集群上运行,从而提供一定程度的冗余,以帮助最大限度地降低停机风险。

四、选择正确的架构

在托管基础结构时,没有无效的方法。上面讨论的所有体系结构都是有效的。但是,两种体系结构配置之间的选择取决于您如何确定以下因素的优先级。

  • 缩放
  • 成本效益
  • 租户隔离
  • 高可用性
  • 易于管理

随着资源需求的增加,扩展一组大型集群的成本非常高,因为与启动许多小型集群相比,每个集群的成本要高得多。您可以通过向小型集群组添加更多集群来轻松扩展基础架构,从而无限增加容量。

成本效益取决于您如何利用资源。通过在几个大型群集上托管基础结构,通过重用群集范围的资源(如入口控制器、负载均衡器等),可以更高效。拥有许多集群可能会引入资源缺口,并且成本高于您的利用率。

租户隔离有两种类型:软隔离和硬隔离。通过使用 Kubernetes 命名空间、基于角色的访问控制等在大型群集上实现软租户隔离,但由于共享控制平面组件,应用程序仍然可以发现群集上运行的其他应用程序。您可以通过在许多小型集群上托管基础架构块来实现硬租户隔离,从而消除共享控制平面组件。

Kubernetes 具有安全和资源限制功能,例如用于控制流量的 NetworkPolicy 资源、用于命名空间级别隔离的 Pod 安全准入、ResourceQuota 对象或 LimitRange 资源的资源限制等等。但是,这些方法需要额外的配置而不是硬隔离,并且无法保护您的基础结构免受每个安全漏洞的影响。

高可用性很难通过少量大型集群实现,因为它的容错能力低于拥有许多小型集群。由于大型集群中的服务中断,您可能会损失大量容量。与重建大型集群相比,您可以轻松地在一组小型集群中重建损坏的集群。

易于管理是拥有几个大型集群的一个吸引人的功能。与大型集群相比,管理由许多小型集群组成的组非常复杂,因为您需要单独与每个集群进行交互。如果您管理大量集群,则必须多次执行日常任务,例如升级 Kubernetes 版本和监控集群运行状况。

五、结论

本指南引导您完成用于托管应用程序的不同体系结构配置。它还比较了不同的配置,包括扩展、成本效率、应用程序/环境隔离、易管理性等。您可以通过根据所讨论的指针分析和评估需求,为应用程序选择正确的集群体系结构。请参阅 Kubernetes 组件概述,了解有关 Kubernetes 集群中各个组件的更多信息。

如何在 Rocky Linux 8 上安装 Apache Cassandra

如果您正在寻找一个功能强大的开源分布式数据库系统,但又不想花费数小时来配置和安装它,那么 Cassandra 是适合您的解决方案。

Cassandra 是一个功能强大的开源分布式数据库系统,旨在处理许多商用服务器上的大量数据,提供高可用性,没有单点故障。相反,数据使用键值存储进行分区并分布在多个服务器上。

一、准备工作

  • 部署新的Rocky Linux 实例
  • 使用 SSH 登录服务器
  • 更新您的Rocky Linux 8 服务器
  • 创建具有 sudo 访问权限的非 root 用户

二、安装 Java OpenJDK

首先,要在系统上运行 Cassandra,必须安装 Java OpenJDK。OpenJDK 是 Java 平台的免费开源实现。下面列出了安装说明。

  1. 运行命令以安装包。在撰写本文时,Java OpenJDK 的最新版本 1.8.xxx。Java OpenJDK 的安装可能需要一些时间才能完成。dnf installjava-1.8.0-openjdk
    $ sudo dnf install java-1.8.0-openjdk -y
  2. 安装完成后,使用以下命令验证系统中已安装的 Java OpenJDK 版本。java -version
    $ java -version
    
    openjdk version "1.8.0_322"
    
    OpenJDK Runtime Environment (build 1.8.0_322-b06)
    
    OpenJDK 64-Bit Server VM (build 25.322-b06, mixed mode)

 三、安装 python

Cassandra 是用 Java 编写的,但是你也需要安装 python,因为cqlsh工具是用 python 编写的。Cqlsh 是 Cassandra 的命令行界面;你需要安装 python 来运行 Cassandra。

  1. 运行命令以在系统中安装软件包。在撰写本文时,python的最新版本是3.6.8。dnf installpython36
    & sudo dnf install python36 -y
  2. 安装完成后,使用命令验证系统中已安装的版本。python3 --version
    $ python3 --version
    
    Python 3.6.8
  3. 运行以下命令以选择默认的 Python 解释器。Cassandra 需要 python v3 或更高版本。因此,您应该从列表中选择最新的一个,并且至少是v3。选择与最新 python 版本对应的数字,然后按 Enter 键。在此演示中,它是选项 2。alternatives --config
    $ alternatives --config python
    
    1           /usr/libexec/no-python
    
    2           /usr/bin/python3

 四、安装 Apache Cassandra

现在,您的系统中已安装了所需的组件,并且可以安装 Apache Cassandra 了。

基本的 Rocky Linux 存储库没有 Cassandra 软件包,因此您需要先将其存储库添加到您的系统中。

  1. 使用文本编辑器创建一个在 /etc/yum.repos.d 目录下命名的新文件。cassandra.reponano
    sudo nano /etc/yum.repos.d/cassandra.repo
  2. 使用以下内容填充文件。指定 RPM 所在的位置()。这里的意思是从这个位置下载最新版本的Apache Cassandra 4.0.3。您始终可以选择其官方存储库中可用的最新版本。cassandra.repobaseurlhttps://downloads.apache.org/cassandra/redhat/40x/40x
    [cassandra]
    
    name=Apache Cassandra
    
    baseurl=https://downloads.apache.org/cassandra/redhat/40x/
    
    gpgcheck=1
    
    repo_gpgcheck=1
    
    gpgkey=https://downloads.apache.org/cassandra/KEYS
  3. 保存并退出文件,方法是按 Ctrl+O、Enter 和 Ctrl+X。运行该命令以使用新添加的存储库更新系统的包管理索引。dnf update
    $ sudo dnf update -y
  4. 运行 Cassandra 命令以检查新存储库是否已正确设置。您将看到新的 Cassandra 存储库在输出中启用。dnf repolist
    $ sudo  dnf repolist cassandra
    
    repo id                          repo name                               status
    
    cassandra                        Apache Cassandra                        enabled
  5. 最后,使用命令安装包。cassandradnf install
    & sudo dnf install cassandra -y
  6. 启动 Cassandra 服务。
    sudo service cassandra start
    
    Reloading systemd:                                         [  OK  ]
    
    Starting cassandra (via systemctl):                        [  OK  ]
  7. 启用 Cassandra 服务以在系统重新启动时启动。
    $ sudo systemctl enable cassandra               
    
    cassandra.service is not a native service, redirecting to systemd-sysv-install.
    
    Executing: /usr/lib/systemd/systemd-sysv-install enable cassandra
  8. 检查 Cassandra 的服务状态。
    sudo service cassandra status
    
    
    
    cassandra.service - LSB: distributed storage system for structured data
    
    
    
    Loaded: loaded (/etc/rc.d/init.d/cassandra; generated)
    
    
    
    Active: active (running) since Mon 2022-02-21 23:35:06 UTC; 4min 44s ago        

 五、保护 Cassandra

保护您的 Cassandra 集群与安装它一样重要。假设您在同一网络上有多个 Cassandra 节点。您应该在开始时保护集群,以防止攻击者访问您的数据库。

  1. 运行以下命令以创建名为 Cassandra 的新防火墙区域。您应该创建一个新区域以与 Cassandra 集群关联,以防止与系统中的其他服务发生冲突。该标志定义新防火墙是永久性的。该标志定义新的防火墙区域。firewall-cmdcassandra-cluster--permanent--new-zone
    $ sudo firewall-cmd --permanent --new-zone cassandra-cluster
    
    success
  2. 重新加载服务。firewalld
    $ sudo firewall-cmd --reload
  3. 将服务器网络 CIDR 添加到新区域中,以便客户端和服务器可以相互通信。
    $ sudo firewall-cmd --zone=cassandra-cluster --add-source=your-CIDR-here/24 --permanent
  4. 运行以下命令以允许访问新区域中 Cassandra 的默认端口。cassandra-cluster
    sudo firewall-cmd --zone=cassandra-cluster --add-port=7000/tcp --permanent
    
    sudo firewall-cmd --zone=cassandra-cluster --add-port=9042/tcp --permanent
  5. 最后,重新加载规则。此时,您的 Cassandra 集群是安全的,只能从您的 CIDR-here/24 访问。firewalld
    sudo firewall-cmd --reload

  六、测试 Cassandra

现在你已经有了一个新的 Cassandra 集群,你可以测试它是否启动并正常运行。

  1. 运行该命令以检查您的 Cassandra 集群状态。该命令将返回所有节点的信息,包括 IP 地址、每个节点的平均负载、数据中心名称、版本以及集群中每个节点的健康统计信息。nodetool status
    $ sudo nodetool status 
    
    Datacenter: datacenter1
    
    =======================
    
    Status=Up/Down
    
    |/ State=Normal/Leaving/Joining/Moving
    
    --  Address    Load       Tokens  Owns (effective)  Host ID                               Rack
    
    UN  127.0.0.1  97.22 KiB  16      100.0%            5607b149-a79e-4e3e-8d98-5b4a26ff698f  rack1
    • U 表示节点已启动。您可以通过查看输出中相应的 U 或 D 来查看哪些节点处于启动或关闭状态。
    • N 表示节点正常。
    • 地址显示节点的 IP 地址。
    • 主机 ID 是每个节点的唯一标识符。
  2. 您还可以使用该命令与 Cassandra 集群进行交互。cqlsh
    $ cqlsh
    
    Connected to Test Cluster at 127.0.0.1:9042
    
    [cqlsh 6.0.0 | Cassandra 4.0.3 | CQL spec 3.4.5 | Native protocol v5]
    
    Use HELP for help.
    
    cqlsh> 
  3. 例如,如果要更改默认名称群集(测试群集),可以使用命令进行更改。替换为所需的值。updateVultr Cluster
    $ UPDATE system.local SET cluster_name = 'Vultr Cluster' WHERE KEY = 'local';
  4. 退出 cqlsh shell。
    $ quit

下次使用该命令时,它将使用新的集群名称。此输出确认您已在系统上成功安装 Cassandra。cqlsh

    $ cqlsh

    Connected to Vultr Cluster at 127.0.0.1:9042

    [cqlsh 6.0.0 | Cassandra 4.0.3 | CQL spec 3.4.5 | Native protocol v5]

    Use HELP for help.

    cqlsh>

可在下一个项目中使用的顶级开源数据库应用程序

一、介绍

多年来,开源社区提出了许多数据库应用程序。庞大的数据库列表有时会让人不知所措,为下一个数据驱动应用程序做出选择可能会令人困惑。

不久前,兼容性是为项目选择正确的数据库解决方案时的主要关键。例如,WordPress总是可以与MariaDB或MySQL服务器一起使用。然而,在现代,来自才华横溢的开发人员的创新为等式增加了许多因素。

今天,在将自己投入数据库系统之前,您需要考虑安全性、可靠性、可伸缩性、报告、支持、易于集成、托管成本、适用性和可维护性。本教程将引导您了解可在下一个项目中使用的顶级开源数据库管理系统及其功能和用例。

二、关系数据库管理系统

关系数据库管理系统(RDBMS)是数据库解决方案的主要流行类别。在此模型中,应用程序将数据存储在基于行的表结构中,可以使用结构化查询语言 (SQL) 查询这些结构。RDBMS 应用程序具有不同的功能,可解决数据的一致性、完整性和准确性问题。

以下是可以在项目中使用的基于 SQL 的主要数据库。

2.1、MySQL 数据库服务器

在部署云原生应用程序时,MySQL是最好的数据库之一,也是内容管理系统(CMS)的首选数据库。它与其他开源应用程序(如WordPress,OpenCart,Drupal,Magento,Joomla等)集成得很好。

MySQL 附带了多种安全功能,包括 TLS、数据加密、密码策略和基于角色的权限。在可扩展性方面,您可以跨服务器池使用 MySQL 组复制功能来实现水平扩展。

MySQL 还支持事务,是需要数据库一致性的关键任务应用程序的不错选择。例如,电子支付解决方案。在一些技术堆栈中使用MySQL 的最受欢迎的公司包括 Uber,Amazon,Twitter,Pinterest 等。

2.1.1、使用 MySQL 服务器的好处

  • 易于与流行的编程语言(如PHP,Golang,Node.js等)集成。
  • 支持流行的 SQL 语言。
  • 高度安全。
  • 支持交易。
  • 在执行基于行的计算时支持窗口函数。
  • 有大量的在线文档用于学习目的。
  • 拥有成本低。

2.1.2、可能的 MySQL 用例

  • 个人博客。
  • 内容管理系统。
  • 电子商务网站。
  • 公司门户。
  • 企业资源规划 (ERP) 应用程序。

按照以下指南在您的 Linux 服务器上安装 MySQL。

  • 在您的 Linux 服务器上安装 MySQL Server。

2.2、MariaDB 数据库服务器

是 MySQL 的一个分支,由最初的 MySQL 开发人员编码,以提供高性能,稳定性和开放性。MariaDB 具有严格的安全措施,包括可插拔身份验证模块 (PAM)、轻量级目录访问协议 (LDAP)、内部安全/密码检查等。一些支持MySQL的CMS,如WordPress,也可能很好地与MariaDB安装配合使用。

此外,MariaDB 服务器支持现代和更好的存储引擎,如 Cassandra。后者允许您在单个数据库服务器中同时运行 SQL 和 NoSQL 函数。MariaDB 的一些最杰出的客户包括三星,Auto Europe,CCV 和诺基亚。

2.2.1、使用 MariaDB 服务器的好处

  • 支持读取扩展和高速多主复制。
  • 经济高效的数据库解决方案。
  • 支持 Kafka,Spark,Python,Java 和 C 的简化数据导入连接器。
  • 支持 SQL 标准。

2.2.2、可能的 MariaDB 用例

  • 像基于云的销售点终端一样构建 CMS。
  • 创建动态企业网站。
  • 管理用户帐户和身份验证。
  • 构建金融应用程序。
  • 创建基于健康的系统。

通过以下链接在您的服务器上安装 MariaDB。

  • 在您的 Linux 服务器上安装 MariaDB 服务器。

2.3、PostgreSQL 数据库服务器

PostgreSQL 是最先进的数据库解决方案之一,是 Ruby,Python 和 Golang 项目开发人员的首选。PostgreSQL 支持高级数据类型,包括数组,JSON,hstore和特殊类型,如几何数据和网络地址。PostgreSQL 具有高度可扩展性,您可以使用它为任务关键型应用程序设置主/副本集群。

其他值得注意的 PostgreSQL 功能包括基于角色的权限,复杂的锁定机制,外键,多列索引,事务,存储过程等。PostgreSQL数据库服务器的主要客户包括 Apple,IMDB,Instagram,Reddit,Skype 和 Spotify。

2.3.1、使用 PostgreSQL 服务器的好处

  • SQL 支持。
  • 高级和自定义数据类型。
  • 按需可扩展性和灾难恢复功能。
  • 强大的访问控制,包括基于角色的权限、LDAP 和通用安全服务应用程序接口 (GSSAPI)。

2.3.2、可能的 PostgreSQL 用例

  • 在 ERP 应用程序中管理用户数据。
  • 在电信应用程序中存储聊天和通话数据。
  • 在电子商务应用程序中运行产品和客户数据。
  • 管理政府和商业智能数据。

按照以下指南在 Linux 服务器上安装 PostgreSQL 数据库。

  • 在 Linux 服务器上安装 PostgreSQL。

三、NoSQL数据库管理系统

NoSQL 不仅是 SQL 的首字母缩写。它是一种使用非表格数据结构来存储信息的数据库体系结构。大多数 NoSQL 应用程序实现键值存储、文档、宽列或图形来存储数据。NoSQL 数据库的出现为开发人员提供了灵活的模式,可以处理大量数据而不会出现可扩展性问题。

以下是您可以在下一个项目中使用的最常见的 NoSQL 数据库。

3.1、Redis 数据库服务器

Redis 是一个内存数据库,它实现键值模型来存储数据。它快速、可靠且安全。由于 Redis 将数据存储在计算机的 RAM 中,因此在缓存等特殊功能方面,它的性能优于所有基于 SQL 的数据库。其灵活的数据结构、简单的命令协议和复制功能使其成为现代应用程序的理想选择。使用Redis的知名公司包括 Twitter,Flickr,GitHub,Craigslist 等。

3.1.1、使用 Redis 服务器的好处

  • 非常快。Redis 每秒可以执行数十万个写入/读取请求。
  • Redis API 库支持主要的编程语言,包括 PHP、Golang、Java、Python 等。这使得集成更容易。
  • Redis 支持低延迟高性能复制,允许您跨多个服务器水平扩展应用程序。
  • 在特殊情况下,您可以将 Redis 配置为将数据持久化到磁盘,以避免在重新启动服务器时丢失数据。

3.1.2、可能的 Redis 用例

  • 在电子商务网站中缓存产品数据或常用信息。
  • 存储会话数据以进行身份验证。
  • 为健身和游戏应用程序创建排行榜。
  • 创建发布者/订阅者应用以分离任务关键型应用程序的前端和后端。

单击下面的链接在您的服务器上安装 Redis。

  • 在您的 Linux 服务器上安装 Redis。

3.2、MongoDB数据库服务器

MongoDB 使用 JavaScript 对象表示法(JSON)格式来存储数据。MongoDB 数据库中的每条记录都称为一个文档。文档可能包含一个或多个键值对,这些键值对允许您创建灵活的文档架构来存储字符串、数字、对象和数组。MongoDB 带有强大的查询和分析工具,用于从庞大的数据库生成报告。一些实施MongoDB的公司包括福布斯,丰田,Sanoma,Vivint 等。

3.2.1、MongoDB 服务器的优点

  • 处理大型数据集时的按需分片。
  • 用于存储非结构化数据的灵活文档架构。
  • 高性能和可用性。MongoDB 比大多数关系数据库更快。
  • 比 SQL 更容易掌握的简单查询语法。

3.2.2、可能的 MongoDB 用例

  • 构建税务和咨询服务应用程序。
  • 处理智能工厂数据。
  • 存储在线学习平台数据。
  • 运行银行交易平台。
  • 创建保险比较应用程序。
  • 构建客户智能应用程序。
  • 运行科学实验。

按照下面的链接安装 MongoDB 应用程序。

  • 在 Linux 服务器上安装 MongoDB。

3.3、流入数据库数据库服务器

InfluxDB 是一个时间序列数据库应用程序,用于开发物联网行业的应用程序。它带有一个内置的HTTP API,允许您使用更少的代码存储和查询数据库中的数据。由于它使用简单的索引模型,InfluxDB 可以处理大量的数据库写入,使其成为时间序列应用程序的最佳选择。使用 InfluxDB 的一些公司包括 Capital One,Texas Instruments,Adobe,MediaLin 等。

3.3.1、InfluxDB服务器的优势

  • 统一的 API 支持,用于处理数据引入、查询、存储和可视化。
  • 可扩展性。InfluxDB 每秒可以处理大量写入,而不会出现可扩展性问题。
  • 实时分析数据,以识别模式/趋势并预测未来结果。

3.3.2、可能的流入数据库用例

  • 存储智能手表、汽车跟踪设备、智能电表等的物联网应用数据。
  • 为按需金融服务提供支持,例如分析不同货币的市场趋势。
  • 监控科学仪器以预测趋势、提高效率并推动未来的发现。

按照以下指南在您的服务器上安装 InfluxDB。

  • 在 Linux 服务器上安装 InfluxDB。

四、结论

本指南将带您了解可在下一个大项目中使用的不同开源数据库管理系统。本教程重点介绍了 SQL 和 NoSQL 数据库,以便您更好地了解根据您的特殊用例可以使用的最佳数据库。对于复杂的应用程序,您可以使用两个数据库系统的组合来形成一个混合系统。例如,在电子商务平台中,您可以使用 Redis 进行身份验证,并使用 MySQL 来存储产品和客户数据。

如何在 Ubuntu 20.04 LTS 上安装 RethinkDB

您是否正在寻找一个易于使用且扩展良好的数据库?RethinkDB 是一个开源分布式文档存储,提供实时推送功能。

本文解释了如何在 Ubuntu 20.04 LTS 上安装 RethinkDB。

一、准备工作

  • 部署 Ubuntu 服务器实例。
  • 使用 sudo 用户登录到服务器。
  • 更新服务器。

二、添加 RethinkDB 存储库和 GPG 密钥

默认的 RethinkDB 包不包含在 Ubuntu 20.04 存储库中,因此您需要在安装 RethinkDB 之前添加它。

  1. RethinkDB团队拥有自己的Ubuntu Linux存储库。将存储库添加到 .APT
    $ source /etc/lsb-release && echo "deb https://download.rethinkdb.com/repository/ubuntu-$DISTRIB_CODENAME $DISTRIB_CODENAME main" | sudo tee /etc/apt/sources.list.d/rethinkdb.list
  2. 该软件包使用 RethinkDB 团队的 GPG 密钥进行签名,因此应添加 GPG 密钥以避免任何警告。通过运行以下命令添加 GPG 密钥。
    $ wget -qO- https://download.rethinkdb.com/repository/raw/pubkey.gpg | sudo apt-key add -
    
    OK
  3. 添加存储库和密钥后,通过运行以下命令进行更新。APT
    sudo apt update -y

 三、在 Ubuntu 20.04 上安装 RethinkDB

添加存储库和密钥后,运行以下命令在 Ubuntu 20.04 上安装 RethinkDB。

    sudo apt install rethinkdb -y

安装过程应该需要一些时间才能完成。安装后,使用以下命令启动 RethinkDB 并使其在启动时自动启动。

    sudo systemctl start rethinkdb 

    sudo systemctl enable rethinkdb

 四、访问 RethinkDB Web 界面

此时,RethinkDB 应该运行在您的 Ubuntu 20.04 服务器上。RethinkDB 还提供了一个 Web 界面来管理您的集群,您可以使用浏览器访问该界面。现在将您的浏览器指向 localhost,并在 URL 末尾添加:8080。

    http://localhost:8080

您的 RethinkDB Web 界面应该会显示出来。

五、结论

现在,您在 Ubuntu 20.04 服务器上有一个 RethinkDB 的工作实例,可用于您的应用程序。

使用 Celery 在 Python 中执行异步任务队列

一、介绍

Celery 是基于异步消息传递的任务队列/作业队列。它可以用作应用程序的后台任务处理器,您可以在其中转储任务以在后台或任何给定时刻执行。它可以配置为同步或异步执行任务。

异步消息传递是一个系统,其中消息存储在发送方和接收方之间。这允许发送者在发送消息后立即继续处理其他事情,也可以在接收者采取任何操作之前堆叠多条消息。

Celery 的主要因素:

  • 任务
  • 任务代理
  • 结果后端
  • 程序

任务是您要发送给 Celery 以在其工作线程中执行的功能。这些是普通的 Python 函数,带有装饰器将它们与其他函数分开。

任务代理是消息传递系统,您将使用它与 Celery 通信以发送任务以供执行。Celery 支持许多代理,如 Redis、RabbitMQ、Amazon SQS 等。

结果后端再次是一个消息传递系统,但在这种情况下,Celery 使用它来存储任务执行结果,然后可以从您的应用程序访问该结果。它支持许多结果后端,如Redis,RabbitMQ(AMQP),SQLAlchemy等。

worker 是不言自明的,它是一个 Celery 进程,在后台运行,等待任务到达任务代理,通常多个工作线程一起运行以实现并发执行。

二、Celery 中的任务生命周期

Celery 执行任务的过程可以分解为:

  • 任务注册
  • 任务执行
  • 结果存储

您的应用程序将任务发送到任务代理,然后由工作线程保留执行,最后任务执行的结果存储在结果后端中。

三、Celery 的应用

了解Celery 可能有点忙,不知道它的正确应用。您可以通过许多不同的方式将其集成到应用程序中。

Celery 最常见的应用:

  • 定期执行 – 需要在间隔后定期运行的任务,例如发送每月新闻稿。
  • 第三方执行 – 与第三方服务交互的任务,例如通过 SMTP 发送电子邮件。
  • 长时间执行 – 需要很长时间才能完成执行的任务,例如压缩文件。

四、使用 Celery 创建您的第一个程序

在本节中,您将学习如何将 Celery 任务集成到 Python 程序中。

4.1、准备

要完成本指南,您将需要:

  • Python 3.7 或更高版本
  • Redis Server,按照 Ubuntu 20.04 上的安装和配置 Redis 进行操作

4.2、安装 Celery

Celery 是用 Python 编写的,可以使用 Python 的软件包安装程序(pip)进行安装。

安装最新版本的 Celery :

pip install celery

安装所需的依赖项以将 Redis 与 Celery 一起使用:

pip install celery[redis]

 4.3、编写你的第一个 Celery 任务

在这里,我们分解了一个非常基本的程序,演示了如何编写现有函数或将现有函数转换为 Celery 任务。您可以复制并粘贴最后提到的最终代码来自己测试。

导入和初始化 Celery 对象

从 celery python 包导入类并将其初始化为任何变量,这里我们使用了该变量。传递给类的第一个参数是我们应用程序的名称。Celeryapp

from celery import Celery



app = Celery(

    'tasks',

    broker="redis://localhost:6379/0",

    backend="redis://localhost:6379/0"

)

由于我们将 Redis 用于我们的代理和后端,因此我们使用关键字参数指定了它。如果不使用 Redis 的默认配置,则可以使用以下格式为环境编写连接字符串。

redis://username:password@hostname:port/db

创建基本 Celery 任务

您可以使用装饰器将任何函数转换为 Celery 任务,该装饰器添加了我们现有函数作为任务运行所需的所有必要功能。@app.task

@app.task

def multiply(a, b):

    import time

    time.sleep(5)

    return a * b

最终代码

您可以将最终代码复制并粘贴到一个名为新文件中,以按照下一节中给出的说明进行操作。tasks.py

from celery import Celery



app = Celery(

    'tasks',

    broker="redis://localhost:6379/0",

    backend="redis://localhost:6379/0"

)



@app.task

def multiply(a, b):

   import time

   time.sleep(5)

   return a * b

4.4、管理 Celery

写完任务后,您需要工作人员在您执行任务时处理任务。

启动 Celery 

通过运行给定的命令来启动 Celery 工作线程,以按照下一节中给出的说明进行操作。确保您位于保存的同一目录中tasks.py

启动 Celery :

celery -A tasks worker -n worker1 -P prefork -l INFO

预期输出:

Start Worker Output

使用的参数:

  • -A的缩写,用于指定工作人员将使用的应用程序。--app
  • -n是它的缩写,用于指定工作人员的名称。--hostname
  • -P是用于指定池类型的缩写,下面将讨论工作器类型。--pool
  • -l是它的缩写,用于指定我们工作人员的日志级别。--loglevel

您还可以使用 的缩写在后台运行工作线程。-D--detach

停止 Celery

处理完所有任务后,您可以通过运行给定的命令手动关闭工作线程。

结束运行的 Celery :

ps auxww | awk '/celery(.*)worker/ {print $2}' | xargs kill -9

4.5、在 Celery 程序中执行任务

现在,工作线程已启动并准备好处理队列,请打开新控制台并执行命令以打开 python 控制台。确保您位于保存的同一目录中pythontasks.py

导入任务:

from tasks import multiply

执行任务:

使用函数将任务执行请求发送到消息代理。.delay()

task1 = mutliply.delay(512, 100)

检查任务状态:

用于检查任务的当前状态。.state

task1.state

获取任务执行结果:

用于获取任务执行结果。.get()

task1.get()

预期输出:

Python Console Output

您可以使用演示的步骤将 Celery 集成到应用程序的工作流中。

 五、程序类型

选择正确的程序类型非常重要,因为它对执行时间和效率有重大影响。本文的这一部分将指导您了解 Celery 中可用的各种类型的工作人员。

 Celery 的类型:

  • 独奏
  • 预分叉
  • 事件小品
  • 格万特

顾名思义,Solo 是一个内联池,这意味着任务不会同时处理。它只创建一个线程,并使用该线程执行任务。

用单人池开始 Celery 程序

celery -A tasks worker --pool=solo --loglevel=info

需要逐个运行的任务的理想选择。需要放弃并发并使用独奏池的用例并不多。

Prefork 池使用 Python 内置的多处理库,它可以同时处理多个任务。线程数可以用标志调整。--concurrency

使用预叉池启动 Celery 程序

celery -A tasks worker --pool=prefork --concurrency=4 --loglevel=info

如果您的任务受 CPU 限制,则是一个理想的选择。如果任务的大部分时间都使用 CPU,则称为 CPU 受限,并且只有在 CPU 更快的情况下才能运行得更快。

CPU 绑定任务的示例:文件转换、压缩、搜索算法等。

Eventlet & Gevent pool 使用协程(也称为绿色线程)执行任务,而不是生成传统线程。它可以同时处理多个任务。可以使用 flag 调整协程的数量。--concurrency

使用事件池启动 Celery 程序

celery -A tasks worker --pool=eventlet --concurrency=500 --loglevel=info

使用 Gevent 池启动 Celery 程序

celery -A tasks worker --pool=gevent --concurrency=500 --loglevel=info

I/O 绑定任务的理想选择。当主要瓶颈是等待 I/O 操作完成的时间时,任务称为 I/O 绑定。您可以将并发数设置得很高,因为这不受可用 CPU 数量的限制,这与预分叉不同。

I/O 绑定任务的示例:发送电子邮件、发出 API 请求等。

注意:eventlet 和 gevent 不是 Python 标准库的一部分,您必须通过运行或pip install celery[eventlet]pip install celery[gevent]

六、结论

您可以使用给定的信息开始将 Celery 集成到您的应用程序中,但这还不是全部,Celery 可以实现更多。大多数 SaaS(软件即服务)Web 应用程序使用 Celery 作为后台任务处理器来执行各种操作。