1. 首页
  2. 分类
  3. 中间件
【ROS2机器人入门到实战】 2.ROS2中间件DDS架构
System
2024-08-23
所有,中间件

ROS2中的DDS（Data Distribution Service）是一种中间件技术，它允许不同的节点进行数据分发和通信。以下是如何在ROS2中配置和使用DDS的简要说明和示例代码。

  1. 安装ROS2和DDS中间件：



# 以RMW_IMPLEMENTATION=rmw_fastrtps_cpp为例
sudo apt update && sudo apt install -y ros-rolling-rmw-fastrtps-cpp
  1. 配置环境变量以使用DDS中间件：



echo "source /opt/ros/rolling/setup.bash" >> ~/.bashrc
source ~/.bashrc
  1. 启动DDS中间件：



# 以Fast RTPS为例
ros2 run rmw_fastrtps_cpp rviz2_launch
  1. 运行ROS2节点并使用DDS通信：



# 启动talker节点
ros2 run demo_nodes_cpp talker
 
# 启动listener节点
ros2 run demo_nodes_cpp listener

以上步骤展示了如何在ROS2中使用DDS中间件进行通信。这是ROS2的核心通信机制之一，它提供了一种在分布式系统中进行节点间数据通信的方法。

- 阅读更多 -
【Vulhub靶场】Nginx 中间件漏洞复现
System
2024-08-23
所有,中间件

Nginx中间件漏洞复现通常涉及到CVE-2019-9193漏洞，该漏洞是因为Nginx在处理包含特制的If-Modified-Since头的请求时，解析日期时间时使用了错误的年份导致的。

以下是复现该漏洞的步骤：

  1. 安装Docker和Docker Compose。
  2. 克隆Vulhub仓库到本地：git clone https://github.com/vulhub/vulhub.git
  3. 进入Nginx相应的环境目录，例如cd vulhub/nginx/CVE-2019-9193
  4. 运行docker-compose up -d启动环境
  5. 使用工具如curl或者wget发送带有特制的If-Modified-Since头的请求。

以下是一个使用curl发送请求的例子：




curl -H 'If-Modified-Since: Sat, 01 Jan 2016 00:00:01 GMT' http://your-nginx-host

如果Nginx版本在2019年9月以后的安全更新补丁发布之前的版本，则可能会出现相应的漏洞。在实际情况中，你需要确保Nginx的版本与漏洞描述相符合，并且使用的If-Modified-Since头也要正确设置。

注意：在实际的渗透测试中，请确保你已经得到了目标的授权，并且不要对任何系统造成破坏。

- 阅读更多 -
Web框架开发-Django中间件
System
2024-08-23
所有,中间件

在Django中，中间件是一个轻量级的插件系统，用于全局修改Django的输入或输出。它是Django的请求/响应处理过程中的一个钩子系统。

以下是一个简单的Django中间件示例，它记录每个请求的用时，并在请求结束后打印出一个简单的消息。




# middlewares.py
 
from datetime import datetime
 
class RequestTimingMiddleware:
    """
    记录每个请求的处理时间并在请求结束后打印简单消息。
    """
    def __init__(self, get_response):
        self.get_response = get_response
 
    def __call__(self, request):
        start_time = datetime.now()
        response = self.get_response(request)
        end_time = datetime.now()
        duration = (end_time - start_time).total_seconds() * 1000  # 转换为毫秒
        print(f"请求处理耗时: {duration} ms")
        return response
 
    def process_request(self, request):
        # 可以在这里编写请求到达之前的逻辑
        pass
 
    def process_response(self, request, response):
        # 可以在这里编写请求结束后的逻辑
        return response

要使用这个中间件，你需要将其添加到你的Django项目的settings.py文件中的MIDDLEWARE配置列表中。




# settings.py
 
MIDDLEWARE = [
    # ...
    'path.to.middlewares.RequestTimingMiddleware',  # 确保替换为实际的路径
    # ...
]

这个中间件类通过继承MiddlewareMixin类（Django 1.10及以后版本）或实现特定的方法（如__call__, process_request, process_response等）来定义。

在这个例子中，__call__方法是中间件被调用的主要方法，其中包含了请求处理的主要逻辑。process_request和process_response是可选的方法，用于在请求前后执行特定逻辑。

- 阅读更多 -
django校验token自定义中间件
System
2024-08-23
所有,中间件



from django.utils.deprecation import MiddlewareMixin
from django.http import JsonResponse
 
class TokenMiddleware(MiddlewareMixin):
    def process_request(self, request):
        # 获取请求头中的token
        token = request.META.get('HTTP_TOKEN', None)
        # 验证token是否正确，这里仅作为示例，实际应该与你的身份验证系统对接
        if token != 'your-custom-token':
            return JsonResponse({'error': 'Invalid token'}, status=401)
 
    def process_response(self, request, response):
        # 如果需要在响应中添加额外的处理，可以在此方法中实现
        return response

这段代码定义了一个名为TokenMiddleware的Django中间件，用于验证HTTP请求中的token是否正确。如果token不正确，则中间件会中断请求并返回一个包含错误信息的JSON响应，状态码为401。这个例子展示了如何在Django项目中实现自定义的中间件来处理请求验证。

- 阅读更多 -
k8s 中间件
System
2024-08-23
所有,中间件

Kubernetes (K8s) 是一个开源的容器编排平台，用于自动化应用容器的部署、扩缩容、维护等。在 K8s 中，常见的中间件包括服务发现和负载均衡工具 Ingress、配置管理工具 ConfigMap 和 Secret、服务网格 Istio 等。

以下是一些常见的 K8s 中间件及其简单使用示例：

  1. Ingress: 提供HTTP和HTTPS的负载均衡，可以将K8s服务暴露给外部。

    


apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: example-service
            port:
              number: 80

  2. ConfigMap: 用于保存配置数据，可以被 Pod 和其他 K8s 资源使用。

    


apiVersion: v1
kind: ConfigMap
metadata:
  name: example-configmap
data:
  config.json: |
    {
      "key": "value"
    }

  3. Secret: 用于保密数据，如密码、SSL证书等，通常用于 ConfigMap，但也可以在 Pod 定义中使用。

    


apiVersion: v1
kind: Secret
metadata:
  name: example-secret
type: Opaque
data:
  username: YWRtaW4=
  password: MWYyZDFlMmU2N2Rm=

  4. Istio: 服务网格工具，提供流量管理、服务间通信的安全性等功能。

    


apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: example-gateway
spec:
  selector:
    istio: ingressgateway
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"

这些只是一些基本的示例，每个中间件都有其特定的配置和用途。在实际应用中，你需要根据具体需求来定义和使用这些资源。

- 阅读更多 -
fastapi 在中间件中获取requestBody
System
2024-08-19
所有,中间件

在FastAPI中，在中间件中直接获取请求体（request body）是不可能的，因为在ASGI应用调用过程中，请求体是一个流，只能被读取一次。如果你需要在中间件中访问请求体数据，你可以在中间件中修改请求对象，将请求体数据缓存起来。

以下是一个示例代码，展示了如何在FastAPI中创建一个中间件来缓存请求体数据：




from fastapi import FastAPI, Request
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import JSONResponse
 
app = FastAPI()
 
class CacheBodyMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # 将请求体缓存到属性中
        body = await request.body()
        request.state.body = body
        
        response = await call_next(request)
        return response
 
@app.middleware("http")
async def add_middleware(request: Request, call_next):
    return await CacheBodyMiddleware.dispatch(request, call_next)
 
@app.post("/items/")
async def create_item(request: Request, item: dict):
    # 使用中间件缓存的请求体数据
    cached_body = request.state.body
    return JSONResponse({"body": cached_body, "item": item})

在这个示例中，CacheBodyMiddleware 中间件将请求体数据缓存到了 request.state.body 中。request.state 是一个特殊的属性，FastAPI用来在请求处理的多个阶段共享数据。然后，在路由处理函数中，你可以通过 request.state.body 访问这个缓存的请求体数据。

请注意，这种方法只适合非流式的请求体数据，如果你需要处理大型文件上传，这种方法可能会导致内存消耗和性能问题。在实际应用中，你应该小心使用这种技巧，并确保它不会破坏应用的其他部分，如数据流的处理。

- 阅读更多 -
分库分表中间件shardingsphere-proxy实战
System
2024-08-19
所有,中间件



-- 创建分库分表规则
CREATE SHARDING ALGORITHM random_db_algorithm (
  TYPE=RANGE,
  COLUMNS=user_id,
  ALGORITHM_CLASS=com.example.ShardingAlgorithm
);
 
CREATE SHARDING ALGORITHM random_table_algorithm (
  TYPE=RANGE,
  COLUMNS=order_id,
  ALGORITHM_CLASS=com.example.ShardingAlgorithm
);
 
CREATE SHARDING TABLE RULES (
  t_order {
    DATANODES="ds${0..1}.t_order_${0..1}",
    TABLE_STRATEGY={
      standard.STRATEGY.INLINE.shard-key=order_id,
      standard.STRATEGY.INLINE.sharding-column=order_id,
      standard.STRATEGY.INLINE.algorithm-expression=random_table_algorithm
    },
    KEY_GENERATOR=snowflake
  },
  t_order_item {
    DATANODES="ds${0..1}.t_order_item_${0..1}",
    TABLE_STRATEGY={
      standard.STRATEGY.INLINE.shard-key=order_id,
      standard.STRATEGY.INLINE.sharding-column=order_id,
      standard.STRATEGY.INLINE.algorithm-expression=random_table_algorithm
    },
    KEY_GENERATOR=snowflake
  }
);
 
CREATE SHARDING DATABASE RULES (
  ds${0..1}.t_order_${0..1} ISSHARED=true,
  ds${0..1}.t_order_item_${0..1} ISSHARED=true
);
 
-- 配置分片键生成策略
CREATE SHARDING KEY GENERATOR snowflake (
  TYPE=SNOWFLAKE,
  COLUMNS=order_id
);

这个实例展示了如何在ShardingSphere中定义数据分片规则，包括数据节点、表策略和数据库策略。同时，它演示了如何使用内置的SNOWFLAKE策略来生成唯一的分片键。这个例子对于理解分库分表的概念和实践具有很好的教育意义。

- 阅读更多 -
【DockerCE】使用docker配置和运行HertzBeat
System
2024-08-19
所有,中间件

要使用Docker配置和运行HertzBeat，你需要创建一个Dockerfile来构建一个包含HertzBeat的Docker镜像，并且可能需要一个配置文件。以下是一个简单的示例：

首先，创建一个Dockerfile：




FROM openjdk:8-jdk-alpine
 
# 设置工作目录
WORKDIR /app
 
# 将HertzBeat的jar包复制到镜像中
COPY hertzbeat-${project.version}.jar /app/hertzbeat.jar
 
# 暴露端口
EXPOSE 1157 1161 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999
 
# 启动HertzBeat
CMD ["java", "-jar", "hertzbeat.jar"]

然后，构建并运行Docker镜像：




# 构建Docker镜像
docker build -t hertzbeat .
 
# 运行Docker容器
docker run -d --name hertzbeat -p 1157:1157 hertzbeat

确保你有一个HertzBeat的jar包，并且替换${project.version}为实际的版本号。

注意：这个示例假设HertzBeat的端口是1157。如果HertzBeat需要其他端口，请在Dockerfile中更新EXPOSE指令，并在docker run命令中映射相应的端口。

- 阅读更多 -
Docker:基于Docker对中间件进行配置、安装和使用操作合集
System
2024-08-19
所有,中间件

以下是一个示例Dockerfile，用于构建一个包含特定中间件的Docker镜像：




# 基于官方Java镜像
FROM openjdk:8-jdk-alpine
 
# 安装中间件所需的包和工具
RUN apk add --no-cache bash git python3 && \
    pip3 install docker-compose
 
# 设置环境变量
ENV MIDDLEWARE_VERSION 1.2.3
ENV MIDDLEWARE_HOME /opt/middleware
 
# 下载并解压中间件
RUN wget -q -O middleware.tar.gz https://example.com/middleware-$MIDDLEWARE_VERSION.tar.gz && \
    mkdir -p $MIDDLEWARE_HOME && \
    tar -xzf middleware.tar.gz -C $MIDDLEWARE_HOME --strip-components=1 && \
    rm middleware.tar.gz
 
# 配置中间件
COPY middleware.conf $MIDDLEWARE_HOME/conf/
 
# 设置工作目录
WORKDIR $MIDDLEWARE_HOME
 
# 暴露中间件默认端口
EXPOSE 1234
 
# 启动中间件
CMD ["./start-middleware.sh"]

这个Dockerfile演示了如何构建一个包含特定版本中间件的Docker镜像。它首先基于OpenJDK镜像来保持镜像尺寸小。然后，它使用apk工具安装了一些必要的包和Python的pip来安装docker-compose。接下来，它下载了中间件的压缩包，解压到了指定的目录，并且配置了中间件。最后，它暴露了中间件的默认端口，并且定义了启动中间件的命令。

- 阅读更多 -
RocketMQ5.0 Cluster集群部署详解及测试
System
2024-08-19
所有,中间件

由于篇幅所限，这里我们只提供部署RocketMQ 5.0集群的核心步骤和代码实例。

  1. 环境准备：确保Java环境已经安装并配置好，RocketMQ需要Java环境来运行。
  2. 下载并解压RocketMQ：



wget https://archive.apache.org/dist/rocketmq/5.0.0/rocketmq-all-5.0.0-bin-release.zip
unzip rocketmq-all-5.0.0-bin-release.zip
cd rocketmq-all-5.0.0-bin-release
  1. 配置集群名称服务器列表（在conf目录下的broker.conf文件中配置）：



brokerClusterName = DefaultCluster
brokerName = broker-a
brokerId = 0
deleteWhen = 04
fileReservedTime = 48
brokerRole = ASYNC_MASTER
flushDiskType = ASYNC_FLUSH
namesrvAddr = n1:9876;n2:9876;n3:9876
  1. 启动NameServer：



nohup sh bin/mqnamesrv &
  1. 启动Broker：



nohup sh bin/mqbroker -c conf/broker.conf &
  1. 测试集群是否部署成功：



sh bin/tools.sh org.apache.rocketmq.example.quickstart.Producer
sh bin/tools.sh org.apache.rocketmq.example.quickstart.Consumer

以上步骤提供了部署RocketMQ 5.0集群的核心过程，包括下载、环境准备、配置集群、启动NameServer和Broker，以及使用官方提供的快速入门示例进行测试。在实际部署时，需要根据具体的网络环境和服务器配置调整配置文件。

- 阅读更多 -
Copyright © 2024 Tech Blog
All Right Reserved | 京ICP备19053165号