一些评估测试集

这是
自动评估基准
系列文章的第三篇，敬请关注系列文章:

• 基础概念
• 设计你的自动评估任务
• 一些评估测试集
• 技巧与提示

如果你感兴趣的任务已经得到充分研究，很可能评估数据集已经存在了。

下面列出了一些近年来开发构建的评估数据集。需要注意的是：

• 大部分数据集有些 “过时”，因为它们是在 LLM 出现之前构建的，当时是为了评估语言文本的某个特定属性 (如翻译、摘要)，但是可能已经不适合现在的 LLM 评估方法了 (现在的评估方法倾向于通用、整体性)。
  (
  如果你有空余时间可以对下列数据集添加出版日期，会对本文非常有帮助!
  )
  (
  这部分后续也会更新包含大语言模型的评估
  )
• 有些数据集可能受到污染，因为它们已经在网络上公开了很多年了。不过这并不意味着在你的任务中它们就毫无用处！

Pre-LLM 数据集

可手动重现的数据集想法

英文原文:
https://github.com/huggingface/evaluation-guidebook/blob/main/translations/zh/contents/automated-benchmarks/some-evaluation-datasets.md

原文作者: clefourrier

译者: SuSung-boy

审校: adeenayakup

02 简单的增删查改

前情提要：承接了01中的
engine
以及
User
类

2-1 了解会话机制

1. 个人理解

   在SQLAlchemy 增删查改中是依赖会话（Session）这个机制进行操作的，我个人的理解是用“会话“进行连接数据库周期的一系列管理操作（以下是ai生成对此会话的理解）

2. ai理解

   在 SQLAlchemy 中，
   sessionmaker
   是用于创建
   会话（Session）
   对象的工厂类，负责与数据库的交互。会话（Session）是 SQLAlchemy ORM 的核心部分，它管理与数据库的连接，并在一次操作中追踪对象的状态变化（如添加、修改、删除），同时处理事务的提交和回滚。

   会话（Session）的作用

   
   
   1. 管理事务
      ：会话负责开始、提交和回滚事务。通过会话，SQLAlchemy 可以在多个数据库操作间提供原子性（即要么全部成功，要么全部失败）。
   2. 对象的持久化
      ：会话在内存中追踪对象的状态变化，确保对象在数据库中得到正确的插入、更新或删除。
   3. 查询管理
      ：会话管理 SQL 查询的生命周期，包括从数据库获取数据，执行查询语句等。

2-2 创建会话

• 流程：

  
  
  1. 导入对应包，依赖其中的
     sessionmaker
  2. 使用
     sessionmaker
     生成新的会话对象
     Session
     ，生成时绑定之前创建过的引擎
  3. 通过
     Session
     对象我们来构造对应的实例【可能有点绕，但一开始2调用的只是我们绑定好的类，我们还需要对这个对象创造实例来进行会话管理操作】

• 官方的用例参考，他用的数据库类型不一样，但是思路是一样的：

  eg1：

  from sqlalchemy import create_engine
  from sqlalchemy.orm import sessionmaker
  
  # an Engine, which the Session will use for connection
  # resources
  engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/")
  
  Session = sessionmaker(engine)
  
  with Session() as session:
      session.add(some_object)
      session.add(some_other_object)
      session.commit()
  

  
  

  eg2
  ：这个就是后文使用的创建实例进行操作了

  session = Session()
  try:
      session.add(some_object)
      session.add(some_other_object)
      session.commit()
  finally:
      session.close()
  

  
  

  eg3
  ：

  Session = sessionmaker(engine)
  
  with Session.begin() as session:
      session.add(some_object)
      session.add(some_other_object)
  # commits transaction, closes session
  

• 看完官方的实例，来写我们自己的会话管理了：

  
  
  1. 简化版：
  
  

  from test_package_sql import engine, User #这个只是导入01文件提及的engine和User类，名字自己改一下
  from sqlalchemy.orm import sessionmaker
  
  Session = sessionmaker(bind=engine)#先通过时间创造器绑定引擎->创建这个会话类
  
  session = Session()#根据我们自己的Session类创建属于我们自己的实例对象用于后续操作
  

  
  

  2. 详细版：

     from sqlalchemy import create_engine, Column, Integer, Float, String
     from sqlalchemy.orm import declarative_base
     
     from sqlalchemy.orm import sessionmaker
     
     local_url = "sqlite:///02_test.db"
     engine = create_engine(url=local_url)
     local_base = declarative_base()
     class User(local_base):
         __tablename__ = "User"
         id = Column(Integer, primary_key=True)
         name = Column(String)
         age = Column(Integer)
     
     local_base.metadata.create_all(engine)
     

2-3 增

1. 事前bb【觉得烦的可以略过】

   在进行增删查改前，必须再强调一下这个会话机制的流程：
   创建会话->进行管理操作（包括但不不限于增删查改）->提交会话管理
   【注意，提交时的更改的只是当前会话状态，言下之意，你提交了一次再修改，没提交那还是之前提交的状态】

2. 流程介绍【增加单个
   User对象
   】

   
   

   • 创建需要增添的实例——
     必须与User类相匹配
     ，就是说是User类对象

   • 使用对话机制的
     session.add
     接口进行添加

   • 添加若干个后，结束则使用
     session.commit()
     进行修改后的提交

     主函数直接调用就好，我这样子写好封装，看得也清楚，很简单对吧

   
   

   def add_one():
       User1 = User(name="arthur",age=18)
       User2 = User(name="lihua",age=21)
       session.add(User1)
       session.add(User2)
       session.commit()
   

   
   

   • 增添效果如下【db为空时】：

     

     下一集我再对如何显示数据库做一个解释吧，毕竟是从零开始（bushi）

3. 增添多个对象【或者是User_list】

   只需要修改接口以及传入参数就好了，使用
   session.add_all()
   接口

   def add_Users():
       User1 = User(name="arthur", age=18)
       User2 = User(name="lihua", age=21)
       Users = [User1,User2]
       session.add_all(Users)
       session.commit()
   

   
   
   • explain：Users就是User 类（项目）的可迭代对象（列表），让我们看看官方对于这个接口的解释：
   
   

   method
   sqlalchemy.orm.Session.
   add_all
   (
   instances: Iterable[object]
   ) → None

   Add the given collection of instances to this
   Session
   .

   添加实例到Seesion会话中。这句话可能不太好理解，看看他的传参解释其实就很直观，其实就是传入可迭代对象XD

   
   

   • output：

     

     就结束了，其实增删改查不难，接口已经抽象出来了，记住逻辑就好

2-4 查

还是得先说查啊，不然没法删啊0v0

1. 接口介绍

   q = session.query(SomeMappedClass)

   
   

   • 参数介绍：

     SomeMappedClass
     ：所映射的类

     q
     ：返回的类型是
     Query[Any]
     ，即任何满足要求的数据

   • 常用后缀

     
     
     1. .all()
        ：以列表的形式传回搜索的结果
     
     

     session.query(User).all()#用来返回User表的所有数据
     

     
     

     2. sqlalchemy.orm.Query.
        filter_by
        (* *kwargs)
        ¶
        这个是常用的简化版的搜索接口。
        ！注意他可以同时接收多个变量,且只使用等值过滤条件

        results = session.query(User).filter_by(ag,e=21)
        results = session.query(User).filter_by(age=21，name="lihua")
        

     3. session.query(Model).filter(condition)

        运行使用多个复杂的表达式，支持更多条件类型，
        支持手动连接多个条件
        ：如果需要多个条件，可以使用
        AND
        或
        OR
        手动连接条件。但就说注意对比时需要
        User.xxx
        --你自己定义的类表

        results = session.query(User).filter(User.name == 'arthur')#不止支持== ，还支持其他比较运算符
        

     4. .one_or_none()

        用于查找
        是否只有一个
        或者
        none个
        ，找到多个则会报错

   
   

   2. 编码

      其实把上面的看懂了就已经学会了如何搜索了

      
      

      • 简单搜索法：

        def search():
            results = session.query(User).filter_by(age=21)
            for result_one in results:
                print(result_one)
        

        
        

        

      • 使用传统接口更多扩展的的搜索：

        def other_way_search():
            results = session.query(User).filter(User.name == 'arthur')
            for result_one in results:
                print(result_one)
        

2-5 删

• 删除主要运用到
  session.delete(object)
  接口，主要有以下两种用法：

1. 删除单个对象：

session.delete(object)#object是单个对象
session.commit()

2. 删除多个满足条件的对象

   session.query(Model).filter(condition).delete()
   session.commit()
   

   
   

   流程大概是：
   找到想要删除的对象->删除->提交

• code：

  def remove_one():#单个
      results = session.query(User).filter_by(age=21).first()#找到第一个
      session.delete(results)
      session.commit()
  

  
  

  原数据库：

  

  删除后：

  

  def remove_all():#多个
      results = session.query(User).filter_by(name='arthur').delete()
      session.commit()
  

  
  

  删除后：

  

• 删除尾声：

  删除就结束了，最后各位可以尝试把lihua也删除，然后根据上面的教程添加再添加4个User信息，其中要有两个age、name不一样

  参考code：

  def add_4new_user():
      User1 = User(name='arthur', age=18)
      User2 = User(name='Abigail Williams',age=14)
      User3 = User(name='caster', age=21)
      User4 = User(name='Lilith', age=22)
      users = [User1,User2,User3,User4]
      session.add_all(users)
      session.commit()
  

  
  

  结果：

  

2-6 改

改其实最简单，找到对应的
object
然后修改，提交即可，非常朴实无华

def update_f():
    caster = session.query(User).filter_by(name="caster").one_or_none()#找到一个caster的信息
    caster.age = 18			#修改就好啦
    session.commit()		#记得提交

part2结束，感谢观看，读者可以自行实践一下增删查改，最好融合起来一起实践

可能您还没有听说过，GitHub 刚刚宣布了 Copilot Free（免费版）！好消息是：您现在已经可以在 Visual Studio 中开始使用 Copilot Free 了。它现在已经可用了，我们将在1月份对更精简的体验进行最后的润色。

我们很高兴能为整个 Visual Studio 家族带来这些好处。有了 Copilot Free，您将拥有人工智能驱动的工具，就在您的指尖——更智能的调试，人工智能生成的提交消息，人工智能断点放置，当然还有代码补全，聊天等等。开发人员已经看到 Copilot 的速度提高了25%，现在您可以在 Visual Studio 中亲身体验这种提升。

准备好尝试一下了吗？

https://github.com/login?return_to=https%3A%2F%2Fgithub.com%2Fsettings%2Fcopilot

一些建议

1. 现在就试试吧：不要犹豫或者仅仅是等待。今天就在 Visual Studio 中试用 GitHub Copilot Free 吧。请注意，目前，当您达到使用限制时，您不会收到通知，但我们会在1月份为您提供更新。

2. 保持更新：让您的 Visual Studio 安装保持最新状态并订阅预览频道。通过保持在最前沿，您将成为第一个享受最新更新的人，确保您在我们推出新功能时充分利用 Copilot Free。

展望一月

在 Visual Studio 中使用 Copilot Free 会更容易。当您达到使用限制时，您将看到清晰的指标——不再需要猜测。如果您发现自己需要更多，升级到无限制计划将是平滑和无缝的，这样就能让您的想法源源不断。

请关注这些更新的最新预览，不要忘记通过开发者社区分享您的反馈！

原文连接：https://devblogs.microsoft.com/visualstudio/github-copilot-free-is-here-in-visual-studio/

前言
本文是关于iced库的部件介绍，iced库是基于rust的GUI库，作者自述是受Elm启发。
iced目前的版本是0.13.1，相较于此前的0.12版本，有较大改动。
本合集是基于新版本的关于分部件（widget）的使用介绍，包括源代码介绍、实例使用等。

环境配置
系统：window10
平台：visual studio code
语言：rust
库：iced 0.13

iced布局简介

iced中用于布局的部件有column、row等，我们在之前的博文里的示例代码中，就使用了column布局，也就是纵向排列的布局。同样，顾名思义，row即是横向布局。
二者可以嵌套使用，形成纵、横布局。

1、column布局

在iced中的定义就是：

//! Distribute content vertically.

创建一个column布局有几种方式，在我们前文的示例中，使用了column！这样的方式，这是一个快捷的方式，属于iced官方定义的一个宏macro：

官方源码

#[macro_export]
macro_rules! column {
    () => (
        $crate::Column::new()
    );
    ($($x:expr),+ $(,)?) => (
        $crate::Column::with_children([$($crate::core::Element::from($x)),+])
    );
}

这个宏可以直接创建一个Column实例，也可以根据传入的子项来创建Column实例。
以前文代码为例：

column![
            button("增加Inc").on_press(Message::Inc),
            text(self.count).size(20),
            button("减少Dec").on_press(Message::Dec)
        ]

此处，我们创建了一个column，并在其中添加了两个按钮和一个text，它们将在窗口呈纵向排列，我们可以通过设置column的spacing属性来调整其中元素之间的间隙。

将spacing设置为10：

我们可以来看一下Column的官方结构体定义：

官方源码

pub struct Column<'a, Message, Theme = crate::Theme, Renderer = crate::Renderer>
{
    spacing: f32,
    padding: Padding,
    width: Length,
    height: Length,
    max_width: f32,
    align: Alignment,
    clip: bool,
    children: Vec<Element<'a, Message, Theme, Renderer>>,
}

可以看到，其参数中，大部分是属性设置，其中children用于设置传入的子元素，也就是你希望在当前窗口某部分程序纵向排列的子元素，可以是任何widget，也可以嵌套布局，如column、row。
比如，我们将前文的按钮、文本的布局设为row，然后再嵌入到column中：

let row1=row![
            button("增加Inc").on_press(Message::Inc),
            text(self.count).size(20),
            button("减少Dec").on_press(Message::Dec)
        ].spacing(10).padding(20);
        column![
           row1,
        ].spacing(10).padding(20)
        .align_x(iced::Center)
        .into()

看下效果：

我们多增加一些部件和嵌套：

let row1=row![
            button("增加Inc").on_press(Message::Inc).width(60),
            text(self.count).size(20),
            button("减少Dec").on_press(Message::Dec).width(60)
        ].spacing(10).padding(20).width(200).height(100);
        let col1=column![
            button("col1").width(60).on_press(Message::None),
            text("col1").size(12),
            button("col1").width(60).on_press(Message::None),
        ].spacing(10).padding(5);
        
        let color1=iced::Color::from_rgba(155.0,0.0,0.0,255.0);
        let cont_row=container(col1)
                                        .style(move |t|styles::mycontainerstyle(t,color1))
                                        .width(100).height(200)
                                        .align_x(iced::Center).align_y(iced::Center);
        let col2=column![
            text("col2").size(12),
        ];
        let color2=iced::Color::from_rgba(0.0,155.0,0.0,255.0);
        let cont_row2=container(col2)
                                        .style(move |t|styles::mycontainerstyle(t,color2))
                                        .width(100).height(200)
                                        .align_x(iced::Center).align_y(iced::Center);
        let col3=column![
            text("col3").size(12),
        ];
        let color3=iced::Color::from_rgba(0.0,0.0,155.0,255.0);
        let cont_row3=container(col3)
                                        .style(move |t|styles::mycontainerstyle(t,color3))
                                        .width(100).height(200)
                                        .align_x(iced::Center).align_y(iced::Center);
        let row_col=row![
            cont_row,cont_row2,cont_row3
        ].spacing(10).padding(20).height(200);
        column![
           row1,
           row_col,
        ].spacing(10).padding(20)
        .align_x(iced::Center)
        .into()

仔细看一下上面的代码，我们在原先的基础上，添加嵌套布局，总体布局是纵向，纵向有两层，第一层是原先的部件，第二层我们又嵌套了横向布局，一共三列，每一列又嵌套了纵向，为了显示区别，我们添加了背景色，其中关于style的使用，本文不做赘述。
看一下效果：

注意图片中的红黄蓝区域，此处我使用了container部件，方便设置背景色，以作区别。
当然，上面的布局看起来可能不是很整齐，但是实现的效果是对的，即column和row的嵌套来实现页面的布局，可以通过设置spacing和padding来微调部件的位置。
下面，我调整一下代码，为了使布局看起来更简洁有效，我们将显示一个按钮九宫格布局，那么就是三列或者三行互相嵌套，而且其中的子元素都是按钮，且居中排布。
先修改一下代码：

let col1=column![
            button(text("col1_1").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col1_2").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col1_3").size(15)).width(80).height(40).on_press(Message::None),
        ].spacing(10);
        
        // let color1=iced::Color::from_rgba(155.0,0.0,0.0,255.0);
        // let cont_row=container(col1)
        //                                 .style(move |t|styles::mycontainerstyle(t,color1))
        //                                 .width(100).height(200)
        //                                 .align_x(iced::Center).align_y(iced::Center);
        let col2=column![
            button(text("col2_1").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col2_2").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col2_3").size(15)).width(80).height(40).on_press(Message::None),
        ].spacing(10);
        // let color2=iced::Color::from_rgba(0.0,155.0,0.0,255.0);
        // let cont_row2=container(col2)
        //                                 .style(move |t|styles::mycontainerstyle(t,color2))
        //                                 .width(100).height(200)
        //                                 .align_x(iced::Center).align_y(iced::Center);
        let col3=column![
            button(text("col3_1").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col3_2").size(15)).width(80).height(40).on_press(Message::None),
            button(text("col3_3").size(15)).width(80).height(40).on_press(Message::None),
        ].spacing(10);
        // let color3=iced::Color::from_rgba(0.0,0.0,155.0,255.0);
        // let cont_row3=container(col3)
        //                                 .style(move |t|styles::mycontainerstyle(t,color3))
        //                                 .width(100).height(200)
        //                                 .align_x(iced::Center).align_y(iced::Center);
        let row_col=row![
            col1,col2,col3
        ].spacing(10).padding(2).align_y(iced::Center);
        // column![
        //    //row1,
        //    row_col,
        // ].spacing(10).padding(20)
        // .width(300).height(300)
        // .align_x(iced::Center)
        // .into()
        let cont=container(row_col)
                                .align_x(iced::Center).align_y(iced::Center)
                                .width(300).height(300);
        cont.into()

上面的布局，有一些代码是之前的代码，但是被注释了，不用管它，我们只关注有效代码，修改后的代码显示的效果如下;

2、row布局

row布局与column布局是完全一样的，除了布局方向，所以就不再赘述了。

3、综述

column和row是iced中常见的布局，但是并不是唯一，iced还有其他可以实现布局的方式，但本文不再赘述，将在后续逐渐展开。
综合本文上述的介绍，哪怕只是使用column和row，经过调整之后，也是能做出比较好看的布局的，当然以上只涉及了布局，还没有仔细去设置样式，包括边框、颜色、阴影等这些样式，这些都将在后续博文中介绍。

前言

书接上文，prometheus已经安装好了，监控数据是有了，我们需要对其进行告警，并且可以发送到对应的平台，比如飞书、钉钉等，这里选择用飞书来测试

环境准备

下载编排文件

本文所有的编排文件，
都在这里

▶ cd /tmp && git clone git@github.com:wilsonchai8/installations.git && cd installations/prometheus

安装alertmanager

alertmanager主要用作对prometheus发来的告警进行响应，包括发送、抑制等

▶ cd installations/prometheus
▶ kubectl apply -f alertmanager.yaml

检查是否启动

▶ kubectl -n prometheus get pod -owide | grep alertmanager
alertmanager-5b6d594f6c-2swpw        1/1     Running   0          69s   10.244.0.17    minikube       <none>           <none>

访问页面

▶ kubectl get node -owide
NAME       STATUS   ROLES           AGE    VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION     CONTAINER-RUNTIME
minikube   Ready    control-plane   6d2h   v1.26.3   192.168.49.2   <none>        Ubuntu 20.04.5 LTS   6.8.0-45-generic   docker://23.0.2

▶ kubectl -n prometheus get svc | grep alertmanager
alertmanager         NodePort   10.110.182.95    <none>        9093:30297/TCP   70s

http://192.168.49.2:30297

测试alertmanager

1. 定义一个测试的deployment

▶ kubectl create deployment busybox-test --image=registry.cn-beijing.aliyuncs.com/wilsonchai/busybox:latest -- sleep 33333
deployment.apps/busybox-test created

▶ kubectl get pod
NAME                           READY   STATUS    RESTARTS   AGE
busybox-test-fcb69d5f9-tn8vx   1/1     Running   0          6s

2. 定义告警规则

我们定义当deployment的副本是为0就告警，修改prometheus configmap

在最底部追加，相当于新增一个配置文件，里面专门定义告警规则

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-cm
  labels:
    name: prometheus-cm
  namespace: prometheus
data:
  prometheus.yml: |-
    global:
      scrape_interval: 5s
      evaluation_interval: 5s

    alerting:
      alertmanagers:
        - static_configs:
            - targets: ['alertmanager:9093']

    rule_files:
      - /etc/prometheus/*.rules

    scrape_configs:
      - job_name: 'prometheus'
        static_configs:
        - targets: ['localhost:9090']

      - job_name: "prometheus-kube-state-metrics"
        static_configs:
          - targets: ["kube-state-metrics.kube-system:8080"]

      - job_name: 'kubernetes-nodes'
        tls_config:
          ca_file: /var/run/secrets/kubernetes.io/serviceaccount/ca.crt
        bearer_token_file: /var/run/secrets/kubernetes.io/serviceaccount/token
        kubernetes_sd_configs:
        - role: node
        relabel_configs:
        - source_labels: [__address__]
          regex: '(.*):10250'
          replacement: '${1}:9100'
          target_label: __address__
          action: replace
        - action: labelmap
          regex: __meta_kubernetes_node_label_(.+)

# 从这里是新加的
  prometheus.rules: |-
    groups:
    - name: test alert
      rules:
      - alert: deployment replicas is 0
        expr: kube_deployment_spec_replicas == 0
        for: 30s
        labels:
          severity: slack
        annotations:
          summary: deployment replicas is 0

然后重启prometheus，查看告警是否生效

3. 触发告警

▶ kubectl scale --replicas=0 deploy busybox-test

等待些许片刻，查看alertmanager页面

已经有告警触发了

发送到飞书

我们已经有一个告警了，但是目前没法通知出来，需要给他告警到飞书去

1. 创建飞书的告警群组，并创建机器人拿到机器人的webhook

webhook:

https://open.feishu.cn/open-apis/bot/v2/hook/*******************

2. 创建发送消息的服务

这里我们选用python tornado web服务来接收从alertmanager发送的告警信息

from tornado.ioloop import IOLoop
import tornado.httpserver as httpserver
import tornado.web
import requests
import json

WEBHOOK_URL = 'https://open.feishu.cn/open-apis/bot/v2/hook/********'

def send_to_feishu(msg_raw):
    headers = { 'Content-Type': 'application/json' }
    for alert in msg_raw['alerts']:
        msg = '## 告警发生 ##\n'
        msg += '\n'
        msg += '告警：{}\n'.format(alert['labels']['alertname'])
        msg += '时间：{}\n'.format(alert['startsAt'])
        msg += '级别：{}\n'.format(alert['labels']['severity'])
        msg += '详情：\n'
        msg += '    deploy：{}\n'.format(alert['labels']['deployment'])
        msg += '    namespace：{}\n'.format(alert['labels']['namespace'])
        msg += '    content：{}\n'.format(alert['annotations']['summary'])
        data = {
            'msg_type': 'text',
            'content': {
                'text': msg
            }
        }
        res = requests.Session().post(url=WEBHOOK_URL, headers=headers, json=data)
        print(res.json())

class SendmsgFlow(tornado.web.RequestHandler):
    def post(self, *args, **kwargs):
        send_to_feishu(json.loads(self.request.body.decode('utf-8')))

def applications():
    urls = []
    urls.append([r'/sendmsg', SendmsgFlow])
    return tornado.web.Application(urls)

def main():
    app = applications()
    server = httpserver.HTTPServer(app)
    server.bind(10000, '0.0.0.0')
    server.start(1)
    IOLoop.current().start()

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt as e:
        IOLoop.current().stop()
    finally:
        IOLoop.current().close()

本脚本已上传至仓库

3. 修改alertmanager configmap

修改alertmanager的configmap，把webhook_configs改为sendmsg的api地址

apiVersion: v1
kind: ConfigMap
metadata:
  name: alertmanager-config
  namespace: prometheus
data:
  alertmanager.yml: |-
    global:
      resolve_timeout: 5m
    route:
      group_by: ['alertname', 'cluster']
      group_wait: 30s
      group_interval: 5m
      repeat_interval: 5m
      receiver: default
    receivers:
    - name: 'default'
      webhook_configs:
        - url: 'http://127.0.0.1:10000/sendmsg'

重启alertmanager

4. 检查飞书

至此，一个简单告警流程制作完成

联系我

• 联系我，做深入的交流

至此，本文结束
在下才疏学浅，有撒汤漏水的，请各位不吝赐教...