Cloudwatch on SRE运维博客

如何使用 Lambda 自动添加CloudWatch所有实例磁盘告警及 SNS 通知

Wenlong — Sat, 06 May 2023 14:25:09 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230506425079/
相关话题：https://www.cnsre.cn/tags/lambda/

利用Lambda轻松实现EC2实例监控

最近新增了一些服务器，因为每个服务器的基础监控都是要做的。我就想，如何能够快速便捷的方式把这些基础指标都监控上呢？本文将详细介绍如何通过Lambda自动为所有EC2实例添加CloudWatch磁盘告警,并在磁盘利用率超过阈值时,通过SNS主题发送通知。

准备工作

在开始前,我们需要准备:

AWS账号:开通一个AWS账号。
SNS主题:在SNS上创建一个主题,并添加订阅者。订阅方式可以是邮件、短信等。
VPC ID:登录VPC控制台获取VPC ID。
Lambda：需要创建一个Lambda。

创建SNS主题

接下来,我们需要在AWS SNS上创建一个主题,并将订阅者添加到主题中。这些订阅者将会接收磁盘使用超过阈值时的通知。我们可以选择电子邮件、短信等通知方式。

登录到 Amazon SNS 控制台。

单击左侧面板上的“主题”,然后单击“创建主题”。

输入主题名称和主题显示名称,单击“创建主题”。

在主题页面上,单击“订阅”,选择希望接收通知的通知方式。

根据选定的订阅类型输入相关信息,单击“创建订阅”。
在主题页面上,您将看到已创建的订阅。
举个例子,如果我们选择“邮件”作为订阅方式:
在“电子邮件订阅”下,输入接收通知的电子邮件地址。
单击“创建订阅”。
您应会收到一封来自AWS通知的验证电子邮件。请按照电子邮件中的说明进行验证。
一旦验证通过,该订阅将变为“已验证”状态。

现在,当CloudWatch告警触发并调用SNS主题时,验证的电子邮件地址将收到有关警报的电子邮件通知。我们也可以添加多个订阅以接收通过不同渠道的通知,例如电子邮件、短信等。添加订阅者后,我们可以在SNS主题的“概述”页查看订阅的详细信息和状态。在测试Lambda函数时,这有助于确保订阅设置正确和通知能正常发送。

创建Lambda函数

接下来,我们可以在Lambda控制台创建一个新的Lambda函数。

访问 Amazon Lambda 控制台,点击“创建函数”。

选择“从头开始” ,输入函数名称,如“create_cloudwatch_alarm_for_ec2_disk_usage”。
选择Python作为运行环境,选择创建具有基本 Lambda 权限的新角色。
点击“创建函数”。

编写Lambda函数代码

代码我已经写好了，各位大佬收好。代码功能是为所有EC2实例设置CloudWatch磁盘告警,当磁盘利用率超过阈值时,通过SNS主题发送通知。

连接EC2客户端。
获取VPC中运行的EC2实例列表。
遍历实例创建CloudWatch磁盘使用百分比告警。默认阈值是80%。
告警触发SNS主题“you_sns_arn”。

将下面代码复制后进行部分修改。然后替换掉原有代码后，然后保存并部署。

下面是具体代码内容：

'''
Author       : Wenlong Xue 
Date         : 2023-02-27 13:35
LastEditors  : Wenlong Xue 
LastEditTime : 2023-02-27 17:52
Description  : 为 VPC 中的 EC2 实例创建磁盘使用百分比的 CloudWatch 告警，并在磁盘使用超过阈值时发送通知到 SNS 主题
'''
import boto3

def lambda_handler(event, context):
    
    # 连接到 EC2 客户端
    ec2 = boto3.client('ec2')
    
    # 获取 VPC 中运行中的实例列表
    response = ec2.describe_instances(
        Filters=[
            {
                'Name': 'vpc-id',
                'Values': ['vpc-xxxxxx']      # 修改VPC ID
            },
            {
                'Name': 'instance-state-name',
                'Values': ['running']
            }
        ]
    )
    
    # 遍历实例并为磁盘使用百分比创建 CloudWatch 告警
    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            
            # 获取实例 ID 和 Name 标签
            instance_id = instance['InstanceId']
            instance_name = ''
            for tag in instance['Tags']:
                if tag['Key'] == 'Name':
                    instance_name = tag['Value']
                    break
            
            # 创建磁盘使用百分比的 CloudWatch 告警
            cloudwatch = boto3.client('cloudwatch')
            cloudwatch.put_metric_alarm(
                AlarmName='{}-磁盘使用百分比'.format(instance_name),
                AlarmDescription='{} - 磁盘使用百分比'.format(instance_name),
                ActionsEnabled=True,
                AlarmActions=['you_sns_arn'],   # 修改sns主题,如:arn:aws-cn:sns:cn-north-1:xxxxx:HighDiskUsed
                MetricName='disk_used_percent', # 根据情况修改
                Namespace='CWAgent',            # 根据情况修改
                Dimensions=[
                    {
                        'Name': 'InstanceId',
                        'Value': instance_id
                    }
                ],
                Statistic='Maximum',
                Period=300,
                EvaluationPeriods=1,
                Threshold=80.0,
                ComparisonOperator='GreaterThanOrEqualToThreshold'
            )

给IAM角色添加权限

因为创建具有基本 Lambda 权限的新角色的权限并不完整，所以我们要把代码中所要用到的权限给到这个新角色。

首先,Lambda中找到这个觉得然后给他添加对应的权限。

找到创建的Lambda 函数。
选择函数汇总的配置–权限。
找到执行角色，并点击角色名称连接。

点击添加权限，选择附加策略。
添加 CloudWatchFullAccess 和 AmazonEC2ReadOnlyAccess 权限

最后权限如下：

注意

⚠️ 若提示确少什么权限就补充什么权限。

测试函数

现在,我们已经创建Lambda函数和SNS主题,并将订阅者添加到主题。我们可以测试Lambda函数功能。

我们可以手动运行测试来观察 CloudWatch告警项有没有被添加。
我们也可以进行添加触发器。如：固定时间段运行一次，来遍历新加的服务器。然后添加告警项。

常见问题及解决方案

Q1: 没收到SNS通知怎么办?
A1: 确认订阅邮箱是否正确。检查AWS账号是否有权限向SNS发送通知。
Q2: 如何修改磁盘使用阈值?
A2: 编辑Lambda函数代码,更改"Threshold"的值。
Q3: CloudWatch的告警项中显示数据不足怎么办?
A3: 查看CloudWatch中原本磁盘的指标名称，并修改Lambda函数代码对应的值：MetricName=‘disk_used_percent’；Namespace=‘CWAgent’

参考资料

AWS Lambda文档: https://docs.aws.amazon.com/lambda/
AWS CloudWatch文档: https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/
AWS SNS文档: https://docs.aws.amazon.com/sns/index.html

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/230506425079/
相关话题：https://www.cnsre.cn/tags/lambda/

使用 Lambda 函数将 CloudWatch Log 中的日志归档到 S3 桶中

Wenlong — Tue, 06 Dec 2022 11:48:12 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221205544069/
相关话题：https://www.cnsre.cn/tags/aws/

躺了好久，诈尸了。因为换了工作，所以比较忙一直没有时间去更新博客的内容（主要还是因为懒🤔）

话不多说直接上干货。

需求背景

最近在看费用的时候发现有很大一部分费用都是 cloudwatch log中存储了大量的数据，是因为ec2 将日志传输到了存储到了cloudwatch中。这个存储的多的查询日志的时候收费特别的高。另外一个是因为数据分析用途，大数据分析的同事如果想那到数据的话，还是存储在 S3 中是比较划算和方便的，一个是拿取数据比较方便，另外一个是S3 可以最归档存储，后面的大量数据可以分层储存，以此来降低费用。
如果你也想将你的cloudwatch 中日志组中的日志存储到S3中的话可以参考下这篇文章。

前置条件

创建一个 S3 桶，并修改权限
创建 lambda 函数
有一个Cloudwatch 日志组并且有一天以上的日志
给 lambda分配所需的权限

创建 S3 桶并修改权限

国内S3桶权限配置

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.cn-north-1.amazonaws.com.cn"
            },
            "Action": "s3:GetBucketAcl",
            "Resource": "arn:aws-cn:s3:::<bucket name>"
        },
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "logs.cn-north-1.amazonaws.com.cn"
            },
            "Action": "s3:PutObject",
            "Resource": "arn:aws-cn:s3:::<bucket name>/*",
            "Condition": {
                "StringEquals": {
                    "s3:x-amz-acl": "bucket-owner-full-control"
                }
            }
        }
    ]
}

国外S3桶权限配置

{
    "Version": "2012-10-17",
    "Statement": [
      {
          "Action": "s3:GetBucketAcl",
          "Effect": "Allow",
          "Resource": "arn:aws:s3:::<bucket name>",
          "Principal": { "Service": "logs.us-west-2.amazonaws.com" }
      },
      {
          "Action": "s3:PutObject" ,
          "Effect": "Allow",
          "Resource": "arn:aws:s3:::<bucket name>*",
          "Condition": { "StringEquals": { "s3:x-amz-acl": "bucket-owner-full-control" } },
          "Principal": { "Service": "logs.us-west-2.amazonaws.com" }
      }
    ]
}

S3 桶权限文档链接

创建 lambda 函数

创建 lambda

import boto3
import logging
import time
import datetime
import json

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def export_s3_logs(bucket_name, log_group_name, log_stream_name, days_of_logs=1, timeout=1000):
    '''
    today = datetime.datetime.combine(datetime.datetime.utcnow(), datetime.datetime.min.time())
    day_end = today
    day_start = today - datetime.timedelta(days=days_of_logs)
    '''
    today = datetime.datetime.combine(datetime.datetime.utcnow() + datetime.timedelta(hours=8),
                                      datetime.datetime.min.time()) # UTC+8 

    day_end = today - datetime.timedelta(hours=8) # UTC
    day_start = today - datetime.timedelta(days=days_of_logs, hours=8) # UTC    
   
    #print(day_start)
    ts_start = '{0:.0f}'.format(((day_start - datetime.datetime(1970, 1, 1)).total_seconds())*1000)
    ts_end = '{0:.0f}'.format(((day_end - datetime.datetime(1970, 1, 1)).total_seconds())*1000)
    the_date = '/'.join([str(today.year), '0'+str(today.month)[-2:], '0'+str(today.day)[-2:]]) 
    #folder_name = '/'.join([log_group_name, log_stream_name, the_date])
    folder_name = '/'.join([log_group_name,the_date])
    client = boto3.client('logs')
    
    #print (ts_start, ts_end)#, day_start, day_end,the_date
    
    task_id = client.create_export_task(
        logGroupName=log_group_name,
        #logStreamNamePrefix=log_stream_name,
        fromTime=int(ts_start),
        to=int(ts_end),
        destination=bucket_name,
        destinationPrefix=folder_name
    )['taskId']

    i = 1
    while i<timeout:
        response = client.describe_export_tasks(
            taskId=task_id
        )

        status = response['exportTasks'][0]['status']
        if status == 'COMPLETED':
            result = True
            break
        elif status != 'RUNNING':
            result = False
            break
        i += 1
        time.sleep(interval)
    
    return result

def lambda_handler(event, context):
    region = 'cn-northwest-1' # 日志组所在区域
    bucket_name = '<bucket name>' #同区域内的S3桶名称
    log_group_name = '<log group name>' #日志组名称
    log_stream_name = '1' #默认即可
    log_export_days = 1   #默认即可
    export_s3_logs(bucket_name, log_group_name, log_stream_name, log_export_days)

给 lambda 分配权限

AmazonS3的读写权限
CloudWatchLogsFullAccess

验证桶内的文件

最后会以日期的目录将日志归档起来，以方便日后对归档文件进行梳理。

作者：SRE运维博客
博客地址：https://www.cnsre.cn/
文章地址：https://www.cnsre.cn/posts/221205544069/
相关话题：https://www.cnsre.cn/tags/aws/

安装和配置CloudWatchAgent

Wenlong — Mon, 31 May 2021 11:00:37 +0800

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210531100355/
相关话题：https://www.cnsre.cn/tags/aws/

使用 CloudWatch 代理收集指标和日志

下载 CloudWatch 代理软件包

sudo yum install amazon-cloudwatch-agent

点击查看其他平台软件包

配置文件

配置文件路径及名称 
/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json
#配置启动
sudo /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c file:/opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json
#启动服务
systemctl restart amazon-cloudwatch-agent.service

{
        "agent": {
                "metrics_collection_interval": 60,
                "run_as_user": "cwagent"
        },
        "metrics": {
                "aggregation_dimensions": [
                        [
                                "InstanceId"
                        ]
                ],
                "append_dimensions": {
                        "AutoScalingGroupName": "${aws:AutoScalingGroupName}",
                        "ImageId": "${aws:ImageId}",
                        "InstanceId": "${aws:InstanceId}",
                        "InstanceType": "${aws:InstanceType}"
                },
                "metrics_collected": {
                        "procstat": [
                                {
                                 "pid_file": "/var/run/sshd.pid",
                                 "measurement": [
                                        "cpu_usage",
                                        "memory_rss"
                                ]
                                },
                                {
                                 "pid_file": "/var/run/sshd.pid",
                                 "measurement": [
                                        "read_bytes",
                                        "read_count",
                                        "write_bytes"
                                ],
                                 "metrics_collection_interval": 10
                               },
                        "cpu": {
                                "measurement": [
                                        "cpu_usage_idle",
                                        "cpu_usage_iowait",
                                        "cpu_usage_user",
                                        "cpu_usage_system"
                                ],
                                "metrics_collection_interval": 60,
                                "resources": [
                                        "*"
                                ],
                                "totalcpu": false
                        },
                        "disk": {
                                "measurement": [
                                        "used_percent",
                                        "inodes_free"
                                ],
                                "metrics_collection_interval": 60,
                                "resources": [
                                        "*"
                                ]
                        },
                        "diskio": {
                                "measurement": [
                                        "io_time"
                                ],
                                "metrics_collection_interval": 60,
                                "resources": [
                                        "*"
                                ]
                        },
                        "mem": {
                                "measurement": [
                                        "mem_used_percent"
                                ],
                                "metrics_collection_interval": 60
                        },
                        "swap": {
                                "measurement": [
                                        "swap_used_percent"
                                ],
                                "metrics_collection_interval": 60
                        }
                }
        }
}

{
        "logs": {
                "logs_collected": {
                        "files": {
                                "collect_list": [{
                                                "file_path": "/logArchive/hcaextension/info*.log",
                                                "log_group_name": "RGC-Prod-3in1oven",
                                                "log_stream_name": "info.logs"
                                        },
                                        {
                                                "file_path": "/logArchive/hcaextension/http*.log",
                                                "log_group_name": "RGC-Prod-3in1oven",
                                                "log_stream_name": "http.logs"
                                        }
                                ]
                        }
                }
        },
        "metrics": {
                "append_dimensions": {
                        "AutoScalingGroupName": "${aws:AutoScalingGroupName}",
                        "ImageId": "${aws:ImageId}",
                        "InstanceId": "${aws:InstanceId}",
                        "InstanceType": "${aws:InstanceType}"
                },
                "metrics_collected": {
                        "cpu": {
                                "measurement": [
                                        "cpu_usage_idle",
                                        "cpu_usage_iowait",
                                        "cpu_usage_user",
                                        "cpu_usage_system"
                                ],
                                "metrics_collection_interval": 180,
                                "totalcpu": false
                        },
                        "disk": {
                                "measurement": [
                                        "used_percent",
                                        "inodes_free"
                                ],
                                "metrics_collection_interval": 180,
                                "resources": [
                                        "*"
                                ]
                        },
                        "diskio": {
                                "measurement": [
                                        "io_time",
                                        "write_bytes",
                                        "read_bytes",
                                        "writes",
                                        "reads"
                                ],
                                "metrics_collection_interval": 180,
                                "resources": [
                                        "*"
                                ]
                        },
                        "mem": {
                                "measurement": [
                                        "mem_used_percent"
                                ],
                                "metrics_collection_interval": 180
                        },
                        "netstat": {
                                "measurement": [
                                        "tcp_established",
                                        "tcp_time_wait"
                                ],
                                "metrics_collection_interval": 180
                        },
                        "statsd": {
                                "metrics_aggregation_interval": 60,
                                "metrics_collection_interval": 180,
                                "service_address": ":8125"
                        },
                        "swap": {
                                "measurement": [
                                        "swap_used_percent"
                                ],
                                "metrics_collection_interval": 180
                        }
                }
        }
}

作者：SRE运维博客
博客地址：https://www.cnsre.cn
文章地址：https://www.cnsre.cn/posts/210531100355/
相关话题：https://www.cnsre.cn/tags/aws/