[BMC/iDRAC] RACADM을 이용한 Lifecycle Log 수집 및 처리하기

 

서버 관리에서 로그 모니터링은 시스템 안정성과 문제 해결의 핵심입니다.

효율적인 로그 모니터링 툴을 사용하면 대량의 서버 로그를 한눈에 파악할 수 있고,

알림 기능으로 문제를 신속히 해결할 수 있습니다.

 

하지만, 비용이나 환경적인 제약으로 인해 이러한 툴을 사용할 수 없는 경우,

직접 로그를 수집하고 분석해야 하는 상황도 종종 발생합니다.

Dell 하드웨어를 사용하는 경우 iDRAC에 접속해 Lifecycle Log를 확인하는 것이 대표적인 방법입니다.

 

• 웹 인터페이스를 통한 로그 수집 
  • iDRAC 웹 인터페이스에 로그인합니다.
  • “Maintenance” 탭에서 “Lifecycle Log”를 선택합니다.
  • Log Filter를 설정하고 로그를 수집합니다.

Lifecycle Log

iDRAC에서는 직관적인 웹 인터페이스를 통해 로그를 쉽게 수집할 수 있습니다.

하지만 서버 수가 많을 경우, 각각의 iDRAC에 접속하는 데 시간이 많이 소요되고

로그를 개별적으로 수집하고 분석하는 과정 또한 비효율적인 작업이 될 수 있습니다.

 

여러 서버의 로그를 수집해야 할 경우 RACADM 명령어를 사용하면

CLI 환경에서 일괄 처리가 가능하므로, 시간과 노력을 크게 절약할 수 있습니다.

 

• RACADM install
  • Windows용 Dell iDRAC 툴, v11.2.0.0
  • Linux용 Dell iDRAC 툴, v11.2.0.0

[BMC/iDRAC] RACADM란 무엇인가?

 

• RACADM을 통한 로그 수집  
  • 점검할 서버의 iDRAC IP와 로그인 계정 정보를 확인합니다.
  • RACADM 명령어를 실행합니다.

# lclog

Lifecycle Log를 관리하는 명령어

로그 조회, 원격 내보내기, 주석 추가 기능

# racadm lclog view -i <number of records> -a <agent id> -c <category> 
# -s <severity> -b <sub-category> -q <sequence no> -n <number of records>
# -r <start timestamp> -e <end timestamp>

racadm -r 192.168.0.58 -u root -p calvin lclog view -s Warning -r "2024-11-01 00:00:00" -e "2024-12-01 23:59:59"

"lclog view" 명령어의 옵션으로 로그의 심각도를 기준으로 필터링하거나

시작 및 종료 타임스탬프를 지정하여 특정 시간 범위의 로그 조회도 가능합니다.

 

로그 조회 결과

위 명령어는 192.168.0.58 IP를 가진 iDRAC에서 Warning 수준의 로그를
2024년 11월 1일부터 12월 1일까지 수집하는 예입니다.

 

RACADM은 다중 IP 처리를 지원하지 않으므로 여러 서버에 대해 반복 작업이 필요합니다.
이를 자동화하기 위해 스크립트를 작성하면 보다 효율적으로 로그를 수집할 수 있습니다.

 

# racadm_get_lclog.sh

지정된 시간 범위의 로그를 수집하고 필요시 파일로 저장합니다.

#!/bin/bash

RACUSER="root"
RACPSWD="calvin"
log_output="false" # 로그 저장 여부
log_base_dir="./LifeCycleLog" # 기본 로그 저장 디렉토리
start_time=""
end_time=""
client_name=""

# Usage 출력 함수
usage() {
    echo "Usage: $0 [-h <iDRAC_IP> | -f <file_with_iDRAC_IPs>] [-r <start_time>] [-e <end_time>] [-c <client_name>]"
    echo "Options:"
    echo "  -h <iDRAC_IP>   Specify a single iDRAC IP address"
    echo "  -f <file>       Specify a file containing iDRAC IP addresses (one per line)"
    echo "  -r <start_time> Start time for logs in format 'yyyy-mm-dd HH:MM:SS'"
    echo "  -e <end_time>   End time for logs in format 'yyyy-mm-dd HH:MM:SS'"
    echo "  -c <client_name> Specify a client name for log directory"
    exit 1
}

# 로그 저장 여부 묻기
ask_log_saving() {
    read -p "Do you want to save logs? (y/n): " answer
    case $answer in
        [Yy]*) log_output="true" ;;
        [Nn]*) log_output="false" ;;
        *) echo "Invalid input. Defaulting to no log saving."; log_output="false" ;;
    esac
}

# 옵션 처리
while getopts "h:f:r:e:c:" opt; do
    case $opt in
        h)  # 단일 iDRAC IP
            remote_idrac=$OPTARG
            ;;
        f)  # 파일 입력
            ip_file=$OPTARG
            ;;
        r)  # 시작 시간
            start_time=$OPTARG
            ;;
        e)  # 종료 시간
            end_time=$OPTARG
            ;;
        c)  # 클라이언트 이름
            client_name=$OPTARG
            ;;
        *)  # 잘못된 옵션
            usage
            ;;
    esac
done

# 옵션 유효성 검증
if [[ -z $remote_idrac && -z $ip_file ]]; then
    echo "Error: You must provide either -h or -f option."
    usage
fi

if [[ -n $remote_idrac && -n $ip_file ]]; then
    echo "Error: Options -h and -f cannot be used together."
    usage
fi

# 로그 저장 여부 확인
ask_log_saving

# 로그 디렉토리 설정
if [[ $log_output == "true" ]]; then
    if [[ -n $client_name ]]; then
        log_base_dir="${log_base_dir}/${client_name}"
    fi
    log_date_dir="${log_base_dir}/$(date +"%Y%m%d")"
    mkdir -p "$log_date_dir"
    echo "Logs will be saved in directory: $log_date_dir"
fi

# iDRAC 로그 처리 함수
process_idrac_logs() {
    local ip=$1
    echo "Processing iDRAC: $ip"

    # 명령어 구성
    if [[ -z $start_time && -z $end_time ]]; then
        cmd="racadm -r \"$ip\" -u \"$RACUSER\" -p \"$RACPSWD\" lclog view -s Critical,Warning"
    else
        cmd="racadm -r \"$ip\" -u \"$RACUSER\" -p \"$RACPSWD\" lclog view -s Critical,Warning -r \"$start_time\" -e \"$end_time\""
    fi

    # 로그 저장 경로 생성
    if [[ $log_output == "true" ]]; then
        timestamp=$(date +"%H%M%S")
        log_file="${log_date_dir}/${ip}_${timestamp}.log"
        eval "$cmd" 2>&1 | tee "$log_file"
    else
        eval "$cmd"
    fi

    # 종료 코드 확인
    if [[ $? -ne 0 ]]; then
        echo "Warning: Unable to connect to $ip. Skipping..."
        return 1
    fi
}

# 단일 IP 처리
if [[ -n $remote_idrac ]]; then
    # IP 형식 확인
    if [[ ! $remote_idrac =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
        echo "Error: Invalid IP address format."
        exit 1
    fi
    process_idrac_logs "$remote_idrac"
fi

# 파일 내 IP 처리
if [[ -n $ip_file ]]; then
    if [[ ! -f $ip_file ]]; then
        echo "Error: File '$ip_file' not found."
        exit 1
    fi

    while IFS= read -r ip || [[ -n $ip ]]; do
        # IP 형식 확인
        if [[ ! $ip =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
            echo "Warning: Skipping invalid IP address '$ip'"
            continue
        fi
        process_idrac_logs "$ip"
    done < "$ip_file"
fi

 

실행 결과

날짜별 로그 디렉터리에 저장

여러 서버들의 Lifecycle Log를 RACADM을 이용하여 쉽게 파일로 저장하였습니다.

이제는 수집한 로그를 분석할 차례입니다.

수집한 로그 중 새로운 이벤트를 파악하는 것이 중요합니다.

한 달 전에 수집한 로그와 최근 로그를 비교해 보겠습니다.

 

좌) 20241116_log, 우)20241226_log

직접 두 파일을 비교하며 새로운 로그를 찾아봅시다.

Message를 확인하여 중복된 로그인지 새롭게 나온 로그인지 파악하려면 시간이 상당히 걸릴 수 있습니다. 

또한, 작업하는 과정에서 실수가 발생할 가능성도 있습니다.

이러한 로그들을 직접 비교하는 것은 비효율적이기에 이 또한 스크립트를 작성하여 작업을 수행하도록 해보겠습니다.

 

# new_log_filter.py

로그 파일이 저장된 두 디렉터리를 비교하여 새로운 메시지와 중복 메시지를 구분합니다.

아래 코드 실행은 파이썬 설치가 필요합니다.

import os
import sys

# Parse the provided logs to extract the "Message" values and compare them.

def extract_messages_with_metadata(file_path):
    """Extracts 'Message' along with 'Severity' and 'Timestamp' values from a log file."""
    messages = set()
    metadata = {}
    with open(file_path, 'r', encoding='utf-8') as file:
        current_message = None
        current_severity = None
        current_timestamp = None
        for line in file:
            if line.strip().startswith("Message  "):
                key, value = line.split("=", 1)
                current_message = value.strip()
            elif line.strip().startswith("Severity"):
                key, value = line.split("=", 1)
                current_severity = value.strip()
            elif line.strip().startswith("Timestamp"):
                key, value = line.split("=", 1)
                current_timestamp = value.strip()

            if current_message:
                messages.add(current_message)
                metadata[current_message] = {
                    "Severity": current_severity,
                    "Timestamp": current_timestamp
                }
                current_message = None
                current_severity = None
                current_timestamp = None
    return messages, metadata

def find_logs_by_ip(directory1, directory2):
    """Finds and pairs logs by IP addresses between two directories."""
    logs_by_ip = {}
    for directory, index in zip([directory1, directory2], [0, 1]):
        for root, _, files in os.walk(directory):
            for file in files:
                if file.endswith(".log"):
                    ip = file.split("_")[0]  # Assuming IP is the first part of the filename
                    logs_by_ip.setdefault(ip, [None, None])[index] = os.path.join(root, file)
    return logs_by_ip

def process_logs(directory1_path, directory2_path):
    logs_by_ip = find_logs_by_ip(directory1_path, directory2_path)
    output_lines = []

    for ip, log_files in logs_by_ip.items():
        if not all(log_files):
            continue

        last_log_path, recent_log_path = log_files
        last_log_messages, last_log_metadata = extract_messages_with_metadata(last_log_path)
        recent_log_messages, recent_log_metadata = extract_messages_with_metadata(recent_log_path)

        new_messages = recent_log_messages - last_log_messages
        overlapping_messages = recent_log_messages & last_log_messages

        def format_messages(messages, metadata):
            sorted_messages = sorted(messages, key=lambda m: metadata[m]['Timestamp'], reverse=True)
            return "\n".join([
                f"{metadata[message]['Timestamp']} {metadata[message]['Severity']}: {message}"
                for message in sorted_messages
            ])

        output_lines.extend([
            f"\n\n-----------------------------------New Log Messages for {ip}-----------------------------------------", 
            "\n[New Warnings]", format_messages(
                [m for m in new_messages if recent_log_metadata[m]['Severity'] == 'Warning'], recent_log_metadata
            ),
            "\n[New Criticals]", format_messages(
                [m for m in new_messages if recent_log_metadata[m]['Severity'] == 'Critical'], recent_log_metadata
            ),
            f"\n\n-----------------------------------Last Log Messages for {ip}----------------------------------------",
            "\n[Last Warnings]", format_messages(
                [m for m in overlapping_messages if recent_log_metadata[m]['Severity'] == 'Warning'], recent_log_metadata
            ),
            "\n[Last Criticals]", format_messages(
                [m for m in overlapping_messages if recent_log_metadata[m]['Severity'] == 'Critical'], recent_log_metadata
            )
        ])

    return "\n".join(output_lines)

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python new_log_filter.py <Last_directory_path> <New_directory_path>")
        print("Example: python new_log_filter.py 20241101 20241201")
        sys.exit(1)

    directory1_path, directory2_path = sys.argv[1], sys.argv[2]
    save_output = input("Do you want to save the output messages to a file? (y/n): ").strip().lower() in ["y", "yes"]

    result = process_logs(directory1_path, directory2_path)
    print(result)

    if save_output:
        output_file_path = os.path.join(directory2_path, "new_messages_output.txt")
        with open(output_file_path, 'w', encoding='utf-8') as output_file:
            output_file.write(result)
        print(f"Output saved to {output_file_path}")

실행 결과

각 IP 주소에 대해 새로운 로그와 중복된 로그를 구분하여 출력합니다.

심각도(Warning, Critical) 별로 나뉘어 메시지가 정리됩니다.

 

cf)

로그 기간을 설정하지 않고 모든 로그를 수집하여 비교하면

불필요한 과거 로그가 비교 대상에 포함되어 한번 나온 로그들은 모두 Last Log로 포함이 됩니다.

비교할 두 로그 파일의 기간이 겹치지 않게 설정해야 정확한 결과를 얻을 수 있습니다. 

 

---

RACADM 명령어와 스크립트를 활용하면 로그 모니터링 툴 없이도

다수의 서버에서 발생한 로그를 효율적으로 수집할 수 있습니다.

자동화를 통해 반복 작업을 줄이고 로그 데이터를 체계적으로 관리하면,
툴 사용 대비 큰 비용 절감과 더불어 직접 관리의 장점도 얻을 수 있습니다.

 

 

참고자료

• iDRAC 9 RACADM CLI Guide
• iDRAC 8/7 RACADM CLI Guide