19、使用 Docker 创建爬虫微服务

最新推荐文章于 2025-11-06 11:48:12 发布

QuietPulse

最新推荐文章于 2025-11-06 11:48:12 发布

阅读量29

点赞数

CC 4.0 BY-SA版权

分类专栏： Python爬虫实战精讲文章标签： Docker Nameko 微服务

本文链接：https://blog.youkuaiyun.com/c2d3e4f/article/details/151335532

Python爬虫实战精讲专栏收录该内容

23 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

使用 Docker 创建爬虫微服务

在当今的软件开发中，容器化技术已经成为了一种主流趋势，它能够帮助开发者更高效地部署和管理应用程序。Docker 作为一款流行的容器化平台，为我们提供了便捷的容器创建和管理功能。本文将详细介绍如何使用 Docker 创建和管理容器，以及如何使用 Nameko 框架创建微服务。

1. 下载 RabbitMQ 容器镜像

当我们使用 Docker 时，首先可以从 Docker Hub 下载所需的容器镜像。以 RabbitMQ 为例，执行以下操作：

$ docker pull rabbitmq:3-management

执行该命令后，Docker 会连接到 Docker Hub 并开始下载镜像，根据网络速度，这个过程可能需要几分钟。下载完成后，会有类似如下的输出：

3-management: Pulling from library/rabbitmq
e7bb522d92ff: Pull complete
ad90649c4d84: Pull complete
...
Digest: sha256:c7466443efc28846bb0829d0f212c1c32e2b03409996cee38be4402726c56a26
Status: Downloaded newer image for rabbitmq:3-management

可以使用 docker images 命令验证镜像是否下载成功：

$ docker images
REPOSITORY      TAG             IMAGE ID        CREATED         SIZE
rabbitmq        3-management    6cb6e2f951a8    10 days ago     151MB

2. 运行 RabbitMQ 容器

下载好镜像后，就可以基于该镜像创建并运行容器。具体步骤如下：
- 使用 docker run 命令运行容器：

$ docker run -d -p 15672:15672 -p 5672:5672 rabbitmq:3-management

这里的 -d 选项表示让容器在后台运行， -p 选项用于将主机端口映射到容器端口。RabbitMQ 使用端口 5672 处理实际命令，端口 15672 用于访问 Web UI。命令执行后会输出一个容器 ID，例如：

094a138383764f487e5ad0dab45ff64c08fe8019e5b0da79cfb1c36abec69cc8

使用 docker ps 命令查看正在运行的容器：

$ docker ps
CONTAINER ID    IMAGE                   COMMAND                  CREATED         STATUS         PORTS                                                                                  NAMES
094a13838376    rabbitmq:3-management   "docker-entrypoint..."   5 minutes ago   Up 5 minutes   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp   dreamy_easley

从输出中可以看到容器的详细信息，包括容器 ID、基于的镜像、运行时间、暴露的端口等。
- 验证容器是否正常运行：打开浏览器，访问 http://localhost:15672 ，进入 RabbitMQ 管理 UI 登录页面。使用默认用户名和密码 guest:guest 登录，即可看到管理界面。

3. 创建并运行 Elasticsearch 容器

除了 RabbitMQ，我们还可以使用 Docker 运行 Elasticsearch 容器。具体操作如下：
- 下载 Elasticsearch 镜像：

$ docker pull docker.elastic.co/elasticsearch/elasticsearch:6.1.1

这里使用了完整的镜像名称，因为该镜像位于 Elastic 的 Docker 仓库中。下载完成后，会有相应的提示信息。
- 使用 docker images 命令查看已下载的镜像：

$ docker images
REPOSITORY                                      TAG             IMAGE ID        CREATED         SIZE
rabbitmq                                        3-management    6cb6e2f951a8    12 days ago     151MB
docker.elastic.co/elasticsearch/elasticsearch   6.1.1           06f0d8328d66    2 weeks ago     539MB

运行 Elasticsearch 容器：

$ docker run -e ELASTIC_PASSWORD=MagicWord -p 9200:9200 -p 9300:9300 docker.elastic.co/elasticsearch/elasticsearch:6.1.1

这里的 -e 选项用于设置环境变量，为 Elasticsearch 设置密码。
- 使用 docker ps 命令查看正在运行的容器：

$ docker ps
CONTAINER ID    IMAGE                                           COMMAND                  CREATED         STATUS         PORTS                                                                                  NAMES
308a02f0e1a5    docker.elastic.co/elasticsearch/elasticsearch:6.1.1   "/usr/local/bin/do..."   7 seconds ago   Up 6 seconds   0.0.0.0:9200->9200/tcp, 0.0.0.0:9300->9300/tcp                                       romantic_kowalevski
094a13838376    rabbitmq:3-management                           "docker-entrypoint..."   47 hours ago    Up 47 hours    4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp   dreamy_easley

使用 curl 命令验证 Elasticsearch 是否正常运行：

$ curl localhost:9200
{
    "name": "8LaZfMY",
    "cluster_name": "docker-cluster",
    "cluster_uuid": "CFgPERC8TMm5KaBAvuumvg",
    "version": {
        "number": "6.1.1",
        "build_hash": "bd92e7f",
        "build_date": "2017-12-17T20:23:25.338Z",
        "build_snapshot": false,
        "lucene_version": "7.1.0",
        "minimum_wire_compatibility_version": "5.6.0",
        "minimum_index_compatibility_version": "5.0.0"
    },
    "tagline": "You Know, for Search"
}

4. 停止、重启容器和删除镜像

在使用容器的过程中，可能需要停止、重启容器或删除镜像。具体操作如下：
- 停止容器 ：使用 docker stop 命令停止正在运行的容器，只需输入容器 ID 的前几位，只要能唯一标识该容器即可。例如，停止 Elasticsearch 容器：

$ docker stop 30
30

查看容器状态 ：使用 docker ps 命令查看正在运行的容器，使用 docker ps -a 命令查看所有容器（包括已停止的容器）。

$ docker ps
CONTAINER ID    IMAGE                   COMMAND                  CREATED         STATUS         PORTS                                                                                  NAMES
094a13838376    rabbitmq:3-management   "docker-entrypoint..."   2 days ago      Up 2 days      4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, 15671/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp   dreamy_easley

$ docker ps -a
CONTAINER ID    IMAGE                                           COMMAND                  CREATED         STATUS                     PORTS                                                                                  NAMES
308a02f0e1a5    docker.elastic.co/elasticsearch/elasticsearch:6.1.1   "/usr/local/bin/do..."   11 minutes ago  Exited (143) 5 minutes ago                                                                              romantic_kowalevski
...

重启容器 ：使用 docker restart 命令重启已停止的容器：

$ docker restart 30
30

删除容器 ：使用 docker rm 命令删除已停止的容器：

$ docker stop 30
30
$ docker rm 30
30

删除镜像 ：使用 docker image rm 命令删除镜像，需要输入镜像 ID 的前几位：

$ docker image rm 06
Untagged: docker.elastic.co/elasticsearch/elasticsearch:6.1.1
Untagged: docker.elastic.co/elasticsearch/elasticsearch@sha256:9e6c7d3c370a17736c67b2ac503751702e35a1336724741d00ed9b3d00434fcb
Deleted: sha256:06f0d8328d66a0f620075ee689ddb2f7535c31fb643de6c785deac8ba6db6a4c
...

5. 使用 Nameko 创建通用微服务

在掌握了 Docker 容器的基本操作后，接下来我们将使用 Python 的 Nameko 框架创建一个简单的微服务。

5.1 准备工作

确保 RabbitMQ 容器正在运行，因为 Nameko 默认使用 RabbitMQ 作为消息总线。
安装 Nameko：

pip install Nameko

5.2 创建并运行微服务

示例微服务代码位于 10/01/hello_microservice.py ，代码如下：

from nameko.rpc import rpc

class HelloMicroService:
    name = "hello_microservice"

    @rpc
    def hello(self, name):
        print('Received a request from: ' + name)
        return "Hello, {}!".format(name)

在终端中运行微服务：

$ nameko run hello_microservice
starting services: hello_microservice
Connected to amqp://guest:**@127.0.0.1:5672//

这表明 Nameko 已经找到微服务并连接到了 RabbitMQ。

5.3 调用微服务

可以通过两种方式调用微服务：
- 使用 Nameko 交互式 shell ：在另一个终端窗口中启动交互式 shell：

$ nameko shell
Nameko Python 3.6.1 |Anaconda custom (x86_64)| (default, Mar 22 2017, 19:25:17)
[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] shell on darwin
Broker: pyamqp://guest:guest@localhost
In [1]:

在 shell 中调用微服务：

n.rpc.hello_microservice.hello(name='Mike')

按下回车键后，会得到如下结果：

Out[1]: 'Hello, Mike!'

同时，在运行微服务的终端窗口中会看到额外的输出：

Received a request from: Mike

在 Python 代码中调用微服务 ：示例代码位于 10/01/say_hi.py ，代码如下：

from nameko.standalone.rpc import ClusterRpcProxy

CONFIG = {'AMQP_URI': "amqp://guest:guest@localhost"}

with ClusterRpcProxy(CONFIG) as rpc:
    result = rpc.hello_microservice.hello("Micro-service Client")
    print(result)

运行该脚本：

$ python say_hi.py
Hello, Micro-service Client!

6. 微服务实现原理

hello_microservice.py 代码分析 ：
name = "hello_microservice" ：定义了微服务的实际名称，Nameko 使用该名称来识别微服务。
@rpc 装饰器：用于将 hello 方法暴露为 RPC 风格的方法，调用者会被挂起，直到收到微服务的回复。
say_hi.py 代码分析 ：
ClusterRpcProxy 类：用于创建动态代理，通过配置对象指定 AMQP 服务器的地址，然后可以调用微服务的方法。

总结

通过本文的介绍，我们学习了如何使用 Docker 下载、运行、停止、重启和删除容器，以及如何使用 Nameko 框架创建和调用微服务。这些技术可以帮助我们更高效地开发和部署应用程序，特别是在微服务架构中。希望本文对你有所帮助，让你在容器化和微服务开发的道路上迈出坚实的一步。

使用 Docker 创建爬虫微服务

7. 深入理解 Nameko 微服务

在前面的内容中，我们已经初步了解了如何使用 Nameko 创建和调用微服务。接下来，我们将深入探讨 Nameko 微服务的一些特性和使用场景。

7.1 Nameko 的消息总线机制

Nameko 默认使用 RabbitMQ 作为消息总线，这种机制使得微服务之间的通信更加高效和可靠。消息总线就像是一个中转站，负责接收和分发微服务之间的消息。当一个微服务发送请求时，它会将消息发送到消息总线，消息总线再将消息转发给目标微服务。目标微服务处理完请求后，将响应消息发送回消息总线，最后由消息总线将响应返回给调用方。

这种机制的好处在于，微服务之间不需要直接通信，降低了耦合度。同时，消息总线可以对消息进行缓冲和排队，确保消息的顺序和可靠性。

7.2 微服务的并发处理

Nameko 支持微服务的并发处理，即可以同时处理多个请求。当有多个请求同时到达时，Nameko 会自动分配资源来处理这些请求，提高了系统的吞吐量。

例如，在 hello_microservice.py 中，我们可以对 hello 方法进行一些修改，模拟一些耗时的操作：

import time
from nameko.rpc import rpc

class HelloMicroService:
    name = "hello_microservice"

    @rpc
    def hello(self, name):
        print('Received a request from: ' + name)
        time.sleep(1)  # 模拟耗时操作
        return "Hello, {}!".format(name)

当有多个请求同时到达时，Nameko 会自动处理这些请求，而不会出现阻塞的情况。

7.3 微服务的错误处理

在微服务的开发中，错误处理是非常重要的。Nameko 提供了一些机制来处理微服务中的错误。

例如，在 hello_microservice.py 中，我们可以对 hello 方法进行修改，添加一些错误处理逻辑：

from nameko.rpc import rpc

class HelloMicroService:
    name = "hello_microservice"

    @rpc
    def hello(self, name):
        try:
            print('Received a request from: ' + name)
            return "Hello, {}!".format(name)
        except Exception as e:
            print(f"Error: {e}")
            return "An error occurred"

当 hello 方法出现异常时，会捕获异常并返回错误信息。

8. Docker 与微服务的结合应用

Docker 和微服务是一对非常好的搭档，它们可以相互配合，提高应用程序的开发和部署效率。

8.1 容器化微服务

我们可以将微服务打包成 Docker 容器，这样可以确保微服务在不同的环境中具有一致的运行效果。具体步骤如下：
1. 创建 Dockerfile：在微服务的项目目录下创建一个 Dockerfile，用于定义容器的构建过程。

# 使用 Python 基础镜像
FROM python:3.9

# 设置工作目录
WORKDIR /app

# 复制项目文件到工作目录
COPY . .

# 安装依赖
RUN pip install -r requirements.txt

# 暴露端口
EXPOSE 8000

# 运行微服务
CMD ["nameko", "run", "hello_microservice"]

构建 Docker 镜像：在项目目录下执行以下命令构建镜像：

$ docker build -t hello-microservice .

运行 Docker 容器：使用以下命令运行容器：

$ docker run -d -p 8000:8000 hello-microservice

8.2 Docker Compose 管理多个微服务

当我们有多个微服务时，可以使用 Docker Compose 来管理这些微服务。Docker Compose 可以通过一个 YAML 文件来定义和运行多个 Docker 容器。

以下是一个简单的 Docker Compose 文件示例：

version: '3'
services:
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"
  hello-microservice:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - rabbitmq

在这个示例中，我们定义了两个服务： rabbitmq 和 hello-microservice 。 hello-microservice 依赖于 rabbitmq ，Docker Compose 会自动处理服务之间的依赖关系。

使用以下命令启动 Docker Compose：

$ docker-compose up -d

9. 总结与展望

通过本文的介绍，我们深入学习了如何使用 Docker 创建和管理容器，以及如何使用 Nameko 框架创建和调用微服务。同时，我们还探讨了 Docker 和微服务的结合应用，包括容器化微服务和使用 Docker Compose 管理多个微服务。

这些技术可以帮助我们构建更加高效、可靠和可扩展的应用程序。在未来的开发中，我们可以进一步探索 Docker 和微服务的更多特性和应用场景，例如使用 Kubernetes 来管理容器集群，使用分布式追踪工具来监控微服务的性能等。

以下是一个简单的流程图，展示了使用 Docker 和 Nameko 开发微服务的基本流程：

graph LR
    A[下载 Docker 镜像] --> B[运行 Docker 容器]
    B --> C[安装 Nameko]
    C --> D[创建微服务代码]
    D --> E[运行微服务]
    E --> F[调用微服务]
    F --> G[容器化微服务]
    G --> H[使用 Docker Compose 管理微服务]

希望本文能够对你有所帮助，让你在容器化和微服务开发的道路上取得更好的成果。