发表更新powershell / tip4 分钟读完 (大约535个字)

PowerShell 技能连载 - PDF 处理技巧

在 PowerShell 中处理 PDF 文件是一项常见任务，本文将介绍一些实用的 PDF 处理技巧。

首先，让我们看看基本的 PDF 操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 创建 PDF 信息获取函数
function Get-PDFInfo {
    param(
        [string]$PDFPath
    )
    
    try {
        # 使用 iTextSharp 获取 PDF 信息
        Add-Type -Path "itextsharp.dll"
        $reader = [iTextSharp.text.pdf.PdfReader]::new($PDFPath)
        
        $info = [PSCustomObject]@{
            FileName = Split-Path $PDFPath -Leaf
            PageCount = $reader.NumberOfPages
            FileSize = (Get-Item $PDFPath).Length
            IsEncrypted = $reader.IsEncrypted()
            Metadata = $reader.Info
        }
        
        $reader.Close()
        return $info
    }
    catch {
        Write-Host "获取 PDF 信息失败：$_"
    }
}

PDF 合并：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# 创建 PDF 合并函数
function Merge-PDFFiles {
    param(
        [string[]]$InputFiles,
        [string]$OutputPath
    )
    
    try {
        Add-Type -Path "itextsharp.dll"
        $document = [iTextSharp.text.Document]::new()
        $writer = [iTextSharp.text.pdf.PdfCopy]::new($document, [System.IO.FileStream]::new($OutputPath, [System.IO.FileMode]::Create))
        
        $document.Open()
        
        foreach ($file in $InputFiles) {
            $reader = [iTextSharp.text.pdf.PdfReader]::new($file)
            for ($i = 1; $i -le $reader.NumberOfPages; $i++) {
                $writer.AddPage($writer.GetImportedPage($reader, $i))
            }
            $reader.Close()
        }
        
        $document.Close()
        $writer.Close()
        
        Write-Host "PDF 合并完成：$OutputPath"
    }
    catch {
        Write-Host "合并失败：$_"
    }
}

PDF 分割：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 创建 PDF 分割函数
function Split-PDF {
    param(
        [string]$InputPath,
        [string]$OutputFolder,
        [int[]]$PageRanges
    )
    
    try {
        Add-Type -Path "itextsharp.dll"
        $reader = [iTextSharp.text.pdf.PdfReader]::new($InputPath)
        
        for ($i = 0; $i -lt $PageRanges.Count; $i += 2) {
            $startPage = $PageRanges[$i]
            $endPage = if ($i + 1 -lt $PageRanges.Count) { $PageRanges[$i + 1] } else { $reader.NumberOfPages }
            
            $outputPath = Join-Path $OutputFolder "split_$($startPage)_$($endPage).pdf"
            $document = [iTextSharp.text.Document]::new()
            $writer = [iTextSharp.text.pdf.PdfCopy]::new($document, [System.IO.FileStream]::new($outputPath, [System.IO.FileMode]::Create))
            
            $document.Open()
            
            for ($page = $startPage; $page -le $endPage; $page++) {
                $writer.AddPage($writer.GetImportedPage($reader, $page))
            }
            
            $document.Close()
            $writer.Close()
        }
        
        $reader.Close()
        Write-Host "PDF 分割完成"
    }
    catch {
        Write-Host "分割失败：$_"
    }
}

PDF 加密：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 创建 PDF 加密函数
function Protect-PDF {
    param(
        [string]$InputPath,
        [string]$OutputPath,
        [string]$UserPassword,
        [string]$OwnerPassword
    )
    
    try {
        Add-Type -Path "itextsharp.dll"
        $reader = [iTextSharp.text.pdf.PdfReader]::new($InputPath)
        $stamper = [iTextSharp.text.pdf.PdfStamper]::new($reader, [System.IO.FileStream]::new($OutputPath, [System.IO.FileMode]::Create))
        
        # 设置加密
        $stamper.SetEncryption(
            [System.Text.Encoding]::UTF8.GetBytes($UserPassword),
            [System.Text.Encoding]::UTF8.GetBytes($OwnerPassword),
            [iTextSharp.text.pdf.PdfWriter]::ALLOW_PRINTING -bor
            [iTextSharp.text.pdf.PdfWriter]::ALLOW_COPY -bor
            [iTextSharp.text.pdf.PdfWriter]::ALLOW_FILL_IN -bor
            [iTextSharp.text.pdf.PdfWriter]::ALLOW_SCREENREADERS,
            [iTextSharp.text.pdf.PdfWriter]::ENCRYPTION_AES_128
        )
        
        $stamper.Close()
        $reader.Close()
        
        Write-Host "PDF 加密完成：$OutputPath"
    }
    catch {
        Write-Host "加密失败：$_"
    }
}

这些技巧将帮助您更有效地处理 PDF 文件。记住，在处理 PDF 时，始终要注意文件的安全性和完整性。同时，建议在处理大型 PDF 文件时使用流式处理方式，以提高性能。

发表更新powershell / tip2 分钟读完 (大约303个字)

PowerShell 技能连载 - 容器安全扫描

在容器化环境中，安全扫描是确保部署安全的关键步骤。以下脚本实现Docker镜像漏洞扫描：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
function Invoke-ContainerScan {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory=$true)]
        [string]$ImageName,
        
        [ValidateSet('Low','Medium','High','Critical')]
        [string]$SeverityLevel = 'High'
    )

    $report = [PSCustomObject]@{
        Vulnerabilities = @()
        TotalCount = 0
        RiskRating = 'Unknown'
    }

    try {
        # 执行安全扫描
        $result = docker scan $ImageName --severity $SeverityLevel --format json | ConvertFrom-Json
        
        # 解析扫描结果
        $report.Vulnerabilities = $result.vulnerabilities | Select-Object @{
            Name = 'CVEID'; Expression = {$_.vulnerabilityID}
        }, @{
            Name = 'Severity'; Expression = {$_.severity}
        }, @{
            Name = 'Component'; Expression = {$_.pkgName}
        }
        
        $report.TotalCount = $result.vulnerabilities.Count
        
        # 计算风险评级
        $report.RiskRating = switch ($result.vulnerabilities.Count) {
            {$_ -gt 20} {'Critical'}
            {$_ -gt 10} {'High'}
            {$_ -gt 5} {'Medium'}
            default {'Low'}
        }
    }
    catch {
        Write-Error "扫描失败: $_"
    }

    return $report
}

实现原理：

  1. 集成Docker Scan命令实现镜像安全扫描
  2. 通过JSON格式输出解析漏洞数据
  3. 根据漏洞数量和严重级别计算风险评级
  4. 支持按严重级别过滤扫描结果

使用示例：

1
Invoke-ContainerScan -ImageName 'nginx:latest' -SeverityLevel 'Critical'

最佳实践：

  1. 集成到CI/CD流水线实现自动阻断
  2. 定期更新漏洞数据库
  3. 与镜像仓库集成实现预检扫描
  4. 生成HTML格式的详细报告

注意事项：
• 需要安装Docker Desktop 4.8+版本
• 扫描可能消耗较多系统资源
• 建议配置扫描超时机制

发表更新powershell / tip12 分钟读完 (大约1857个字)

PowerShell 技能连载 - 绿色计算与能耗优化

在当今关注可持续发展的环境中，绿色计算和能耗优化越来越重要。本文将介绍如何使用 PowerShell 实现绿色计算和能耗优化的关键技术。

首先，让我们看看如何监控系统能耗：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
# 创建能耗监控函数
function Measure-PowerConsumption {
    param(
        [string]$ComputerName = $env:COMPUTERNAME,
        [int]$Duration = 3600,
        [int]$Interval = 60,
        [string]$OutputPath
    )
    
    try {
        $metrics = @()
        $endTime = Get-Date
        $startTime = $endTime.AddSeconds(-$Duration)
        
        while ($startTime -lt $endTime) {
            # 获取 CPU 使用率
            $cpu = Get-Counter '\Processor(_Total)\% Processor Time' -ComputerName $ComputerName
            
            # 获取内存使用率
            $totalMem = (Get-CimInstance -ComputerName $ComputerName -ClassName Win32_ComputerSystem).TotalPhysicalMemory / 1GB
            $availableMem = (Get-CimInstance -ComputerName $ComputerName -ClassName Win32_OperatingSystem).FreePhysicalMemory / 1MB
            $memUsage = (($totalMem - $availableMem) / $totalMem) * 100
            
            # 获取磁盘活动
            $diskRead = Get-Counter '\PhysicalDisk(_Total)\Disk Read Bytes/sec' -ComputerName $ComputerName
            $diskWrite = Get-Counter '\PhysicalDisk(_Total)\Disk Write Bytes/sec' -ComputerName $ComputerName
            
            # 获取网络活动
            $netSent = Get-Counter '\Network Interface(*)\Bytes Sent/sec' -ComputerName $ComputerName
            $netReceived = Get-Counter '\Network Interface(*)\Bytes Received/sec' -ComputerName $ComputerName
            
            # 估算功耗 (模拟计算，实际功耗需要专业工具测量)
            $cpuPower = ($cpu.CounterSamples.CookedValue / 100) * 65 # 假设满载 CPU 为 65W
            $memPower = ($memUsage / 100) * 10 # 假设满载内存为 10W
            $diskPower = (($diskRead.CounterSamples.CookedValue + $diskWrite.CounterSamples.CookedValue) / 1MB) * 0.5 # 假设每 MB I/O 消耗 0.5W
            $netPower = (($netSent.CounterSamples.CookedValue + $netReceived.CounterSamples.CookedValue) / 1MB) * 0.2 # 假设每 MB 网络传输消耗 0.2W
            
            $totalPower = $cpuPower + $memPower + $diskPower + $netPower + 20 # 加上基础功耗约 20W
            
            $metric = [PSCustomObject]@{
                Timestamp = Get-Date
                CPUUsage = $cpu.CounterSamples.CookedValue
                MemoryUsage = $memUsage
                DiskReadBytes = $diskRead.CounterSamples.CookedValue
                DiskWriteBytes = $diskWrite.CounterSamples.CookedValue
                NetworkSentBytes = $netSent.CounterSamples.CookedValue
                NetworkReceivedBytes = $netReceived.CounterSamples.CookedValue
                EstimatedPowerWatts = $totalPower
            }
            
            $metrics += $metric
            
            $startTime = $startTime.AddSeconds($Interval)
            Start-Sleep -Seconds $Interval
        }
        
        if ($OutputPath) {
            $metrics | Export-Csv -Path $OutputPath -NoTypeInformation
            Write-Host "能耗监控结果已保存至：$OutputPath"
        }
        
        $averagePower = ($metrics | Measure-Object -Property EstimatedPowerWatts -Average).Average
        $maxPower = ($metrics | Measure-Object -Property EstimatedPowerWatts -Maximum).Maximum
        
        return [PSCustomObject]@{
            ComputerName = $ComputerName
            Duration = $Duration
            Interval = $Interval
            AveragePowerWatts = $averagePower
            MaximumPowerWatts = $maxPower
            TotalEnergyKWh = ($averagePower * $Duration) / 3600000
            DetailedMetrics = $metrics
        }
    }
    catch {
        Write-Host "能耗监控失败：$_"
    }
}

优化电源管理设置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
# 创建电源管理优化函数
function Optimize-PowerSettings {
    param(
        [string]$ComputerName = $env:COMPUTERNAME,
        [ValidateSet('Balanced', 'PowerSaver', 'HighPerformance', 'Ultimate')]
        [string]$PowerPlan = 'Balanced',
        [int]$DisplayTimeout = 600,
        [int]$SleepTimeout = 1800,
        [int]$HardDiskTimeout = 1200
    )
    
    try {
        # 获取和激活所选电源计划
        $powerPlans = powercfg /list | Where-Object { $_ -match '([a-z0-9-]{36})' }
        $planGuid = switch ($PowerPlan) {
            'Balanced' { ($powerPlans | Where-Object { $_ -match 'Balanced' } | Select-String -Pattern '([a-z0-9-]{36})').Matches.Value }
            'PowerSaver' { ($powerPlans | Where-Object { $_ -match 'Power saver' } | Select-String -Pattern '([a-z0-9-]{36})').Matches.Value }
            'HighPerformance' { ($powerPlans | Where-Object { $_ -match 'High performance' } | Select-String -Pattern '([a-z0-9-]{36})').Matches.Value }
            'Ultimate' { ($powerPlans | Where-Object { $_ -match 'Ultimate Performance' } | Select-String -Pattern '([a-z0-9-]{36})').Matches.Value }
        }
        
        if ($planGuid) {
            Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                param($guid)
                powercfg /setactive $guid
            } -ArgumentList $planGuid
            
            Write-Host "已激活电源计划：$PowerPlan"
        } else {
            Write-Host "未找到电源计划：$PowerPlan"
        }
        
        # 设置显示器超时
        Invoke-Command -ComputerName $ComputerName -ScriptBlock {
            param($timeout)
            powercfg /change monitor-timeout-ac $timeout
            powercfg /change monitor-timeout-dc $timeout
        } -ArgumentList $DisplayTimeout / 60
        
        # 设置睡眠超时
        Invoke-Command -ComputerName $ComputerName -ScriptBlock {
            param($timeout)
            powercfg /change standby-timeout-ac $timeout
            powercfg /change standby-timeout-dc $timeout
        } -ArgumentList $SleepTimeout / 60
        
        # 设置硬盘超时
        Invoke-Command -ComputerName $ComputerName -ScriptBlock {
            param($timeout)
            powercfg /change disk-timeout-ac $timeout
            powercfg /change disk-timeout-dc $timeout
        } -ArgumentList $HardDiskTimeout / 60
        
        return [PSCustomObject]@{
            ComputerName = $ComputerName
            PowerPlan = $PowerPlan
            DisplayTimeoutMinutes = $DisplayTimeout / 60
            SleepTimeoutMinutes = $SleepTimeout / 60
            HardDiskTimeoutMinutes = $HardDiskTimeout / 60
        }
    }
    catch {
        Write-Host "电源设置优化失败：$_"
    }
}

管理非工作时间的自动关机：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
# 创建非工作时间管理函数
function Schedule-NonWorkHours {
    param(
        [string]$ComputerName = $env:COMPUTERNAME,
        [ValidateSet('Shutdown', 'Hibernate', 'Sleep')]
        [string]$Action = 'Sleep',
        [int]$StartHour = 18,
        [int]$EndHour = 8,
        [switch]$WeekendShutdown,
        [switch]$EnableWakeUp
    )
    
    try {
        # 创建周一至周五的关机任务
        $taskName = "GreenComputing_$Action"
        $actionString = switch ($Action) {
            'Shutdown' { "shutdown /s /f /t 60" }
            'Hibernate' { "rundll32.exe powrprof.dll,SetSuspendState Hibernate" }
            'Sleep' { "rundll32.exe powrprof.dll,SetSuspendState Sleep" }
        }
        
        # 删除已存在的任务
        Invoke-Command -ComputerName $ComputerName -ScriptBlock {
            param($name)
            schtasks /delete /tn $name /f 2>$null
        } -ArgumentList $taskName
        
        # 创建工作日关机任务
        Invoke-Command -ComputerName $ComputerName -ScriptBlock {
            param($name, $action, $hour)
            schtasks /create /tn $name /tr $action /sc weekly /d MON,TUE,WED,THU,FRI /st $('{0:00}' -f $hour):00:00 /f
        } -ArgumentList $taskName, $actionString, $StartHour
        
        # 如果启用周末关机
        if ($WeekendShutdown) {
            $weekendTaskName = "GreenComputing_Weekend_$Action"
            
            # 删除已存在的周末任务
            Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                param($name)
                schtasks /delete /tn $name /f 2>$null
            } -ArgumentList $weekendTaskName
            
            # 创建周末关机任务
            Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                param($name, $action)
                schtasks /create /tn $name /tr $action /sc weekly /d SAT,SUN /st 20:00:00 /f
            } -ArgumentList $weekendTaskName, $actionString
            
            Write-Host "已创建周末$Action任务：$weekendTaskName"
        }
        
        # 如果启用唤醒
        if ($EnableWakeUp) {
            $wakeTaskName = "GreenComputing_WakeUp"
            
            # 删除已存在的唤醒任务
            Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                param($name)
                schtasks /delete /tn $name /f 2>$null
            } -ArgumentList $wakeTaskName
            
            # 创建唤醒任务
            Invoke-Command -ComputerName $ComputerName -ScriptBlock {
                param($name, $hour)
                $wakeupAction = 'powercfg -requestsoverride Process System Awaymode'
                schtasks /create /tn $name /tr $wakeupAction /sc weekly /d MON,TUE,WED,THU,FRI /st $('{0:00}' -f $hour):00:00 /f
            } -ArgumentList $wakeTaskName, $EndHour
            
            Write-Host "已创建唤醒任务：$wakeTaskName"
        }
        
        return [PSCustomObject]@{
            ComputerName = $ComputerName
            ActionScheduled = $Action
            WorkdaysStartHour = $StartHour
            WorkdaysEndHour = $EndHour
            WeekendShutdownEnabled = $WeekendShutdown
            WakeUpEnabled = $EnableWakeUp
        }
    }
    catch {
        Write-Host "非工作时间管理设置失败：$_"
    }
}

优化虚拟机整合和资源利用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# 创建虚拟机优化函数
function Optimize-VMConsolidation {
    param(
        [string]$HyperVHost,
        [float]$TargetHostCPUUtilization = 70.0,
        [float]$TargetHostMemoryUtilization = 80.0,
        [switch]$MoveVMs,
        [string]$ReportPath
    )
    
    try {
        # 获取 Hyper-V 主机信息
        $hostInfo = Get-CimInstance -ComputerName $HyperVHost -ClassName Win32_ComputerSystem
        $hostProcessor = Get-CimInstance -ComputerName $HyperVHost -ClassName Win32_Processor
        $hostMemory = $hostInfo.TotalPhysicalMemory / 1GB
        $hostCores = ($hostProcessor | Measure-Object -Property NumberOfCores -Sum).Sum
        
        # 获取主机 CPU 和内存使用率
        $hostCpuUsage = (Get-Counter -ComputerName $HyperVHost -Counter "\Processor(_Total)\% Processor Time").CounterSamples.CookedValue
        $hostMemUsage = 100 - (Get-CimInstance -ComputerName $HyperVHost -ClassName Win32_OperatingSystem).FreePhysicalMemory * 100 / ($hostInfo.TotalPhysicalMemory / 1KB)
        
        # 获取所有 VM
        $vms = Get-VM -ComputerName $HyperVHost
        
        # 计算当前资源分配
        $vmSummary = $vms | ForEach-Object {
            $vmCpuUsage = (Get-Counter -ComputerName $HyperVHost -Counter "\Hyper-V Hypervisor Virtual Processor($($_.Name))\% Guest Run Time").CounterSamples.CookedValue
            $vmAssignedMemory = $_.MemoryAssigned / 1GB
            
            [PSCustomObject]@{
                Name = $_.Name
                Status = $_.State
                CPUCount = $_.ProcessorCount
                AssignedMemoryGB = $vmAssignedMemory
                CPUUsage = $vmCpuUsage
                DynamicMemory = $_.DynamicMemoryEnabled
                MemoryDemandGB = $_.MemoryDemand / 1GB
                IdleTime = if ($_.Uptime) { $_.Uptime.TotalHours } else { 0 }
            }
        }
        
        # 计算理想资源分配
        $optimizedVMs = $vmSummary | Where-Object { $_.Status -eq 'Running' } | ForEach-Object {
            $idealCPUs = [Math]::Max(1, [Math]::Ceiling($_.CPUCount * ($_.CPUUsage / $TargetHostCPUUtilization)))
            $idealMemory = [Math]::Max(0.5, [Math]::Ceiling($_.AssignedMemoryGB * ($_.MemoryDemandGB / $_.AssignedMemoryGB) / ($TargetHostMemoryUtilization / 100)))
            
            $reconfigure = $idealCPUs -ne $_.CPUCount -or $idealMemory -ne $_.AssignedMemoryGB
            
            [PSCustomObject]@{
                Name = $_.Name
                CurrentCPUs = $_.CPUCount
                OptimalCPUs = $idealCPUs
                CurrentMemoryGB = $_.AssignedMemoryGB
                OptimalMemoryGB = $idealMemory
                ShouldReconfigure = $reconfigure
                CPUChangePercent = if ($_.CPUCount -gt 0) { (($idealCPUs - $_.CPUCount) / $_.CPUCount) * 100 } else { 0 }
                MemoryChangePercent = if ($_.AssignedMemoryGB -gt 0) { (($idealMemory - $_.AssignedMemoryGB) / $_.AssignedMemoryGB) * 100 } else { 0 }
                PowerSavings = if ($reconfigure) { "High" } elseif ($idealCPUs -eq $_.CPUCount -and [Math]::Abs($idealMemory - $_.AssignedMemoryGB) < 0.5) { "Low" } else { "Medium" }
            }
        }
        
        # 计算整合后的预期节能效果
        $currentPower = $hostCores * 5 + $hostMemory * 2 # 假设每个核心消耗 5W，每 GB 内存消耗 2W
        $projectedPower = $optimizedVMs | Measure-Object -Property OptimalCPUs -Sum | ForEach-Object { $_.Sum * 5 } 
        $projectedPower += $optimizedVMs | Measure-Object -Property OptimalMemoryGB -Sum | ForEach-Object { $_.Sum * 2 }
        
        $powerSavingEstimate = $currentPower - $projectedPower
        $powerSavingPercentage = if ($currentPower -gt 0) { ($powerSavingEstimate / $currentPower) * 100 } else { 0 }
        
        # 如果启用 VM 移动
        if ($MoveVMs) {
            foreach ($vm in $optimizedVMs | Where-Object { $_.ShouldReconfigure }) {
                if ($vm.OptimalCPUs -ne $vm.CurrentCPUs) {
                    Set-VM -ComputerName $HyperVHost -Name $vm.Name -ProcessorCount $vm.OptimalCPUs
                    Write-Host "已将 $($vm.Name) 的 CPU 数量从 $($vm.CurrentCPUs) 更改为 $($vm.OptimalCPUs)"
                }
                
                if ($vm.OptimalMemoryGB -ne $vm.CurrentMemoryGB) {
                    $memoryBytes = $vm.OptimalMemoryGB * 1GB
                    Set-VMMemory -ComputerName $HyperVHost -VMName $vm.Name -StartupBytes $memoryBytes
                    Write-Host "已将 $($vm.Name) 的内存从 $($vm.CurrentMemoryGB) GB 更改为 $($vm.OptimalMemoryGB) GB"
                }
            }
        }
        
        $report = [PSCustomObject]@{
            HyperVHost = $HyperVHost
            HostCores = $hostCores
            HostMemoryGB = $hostMemory
            CurrentHostCPUUsage = $hostCpuUsage
            CurrentHostMemoryUsage = $hostMemUsage
            RunningVMs = ($vms | Where-Object { $_.State -eq 'Running' }).Count
            TotalVMs = $vms.Count
            OptimizationDetails = $optimizedVMs
            EstimatedPowerSavingsWatts = $powerSavingEstimate
            EstimatedPowerSavingsPercent = $powerSavingPercentage
            ReconfiguredVMs = if ($MoveVMs) { ($optimizedVMs | Where-Object { $_.ShouldReconfigure }).Count } else { 0 }
        }
        
        if ($ReportPath) {
            $report | ConvertTo-Json -Depth 5 | Out-File -FilePath $ReportPath -Encoding UTF8
            Write-Host "虚拟机优化报告已保存至：$ReportPath"
        }
        
        return $report
    }
    catch {
        Write-Host "虚拟机整合优化失败：$_"
    }
}

数据中心能效指标计算：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
# 创建数据中心能效指标函数
function Get-DatacenterEfficiency {
    param(
        [string[]]$Servers,
        [float]$FacilityPowerKW,
        [int]$SamplingInterval = 300,
        [int]$SamplingCount = 12,
        [string]$OutputPath
    )
    
    try {
        $measurements = @()
        
        for ($i = 0; $i -lt $SamplingCount; $i++) {
            $serverPowerUsage = 0
            
            foreach ($server in $Servers) {
                # 这里假设使用前面定义的函数测量服务器功耗
                $powerMeasurement = Measure-PowerConsumption -ComputerName $server -Duration 60 -Interval 10
                $serverPowerUsage += $powerMeasurement.AveragePowerWatts
            }
            
            # 转换为千瓦
            $serverPowerKW = $serverPowerUsage / 1000
            
            # 计算 PUE (Power Usage Effectiveness)
            $pue = if ($serverPowerKW -gt 0) { $FacilityPowerKW / $serverPowerKW } else { 0 }
            
            $measurement = [PSCustomObject]@{
                Timestamp = Get-Date
                ServerPowerKW = $serverPowerKW
                FacilityPowerKW = $FacilityPowerKW
                PUE = $pue
            }
            
            $measurements += $measurement
            
            if ($i -lt $SamplingCount - 1) {
                Start-Sleep -Seconds $SamplingInterval
            }
        }
        
        # 计算平均 PUE
        $averagePUE = ($measurements | Measure-Object -Property PUE -Average).Average
        
        # 计算能效评级
        $efficiencyRating = switch ($averagePUE) {
            { $_ -lt 1.2 } { "Excellent (Tier 4)" }
            { $_ -lt 1.5 } { "Very Good (Tier 3)" }
            { $_ -lt 2.0 } { "Good (Tier 2)" }
            { $_ -lt 2.5 } { "Fair (Tier 1)" }
            default { "Poor" }
        }
        
        $results = [PSCustomObject]@{
            Servers = $Servers
            SamplingInterval = $SamplingInterval
            SamplingCount = $SamplingCount
            AveragePUE = $averagePUE
            EfficiencyRating = $efficiencyRating
            MinimumPUE = ($measurements | Measure-Object -Property PUE -Minimum).Minimum
            MaximumPUE = ($measurements | Measure-Object -Property PUE -Maximum).Maximum
            AverageServerPowerKW = ($measurements | Measure-Object -Property ServerPowerKW -Average).Average
            DetailedMeasurements = $measurements
        }
        
        if ($OutputPath) {
            $results | ConvertTo-Json -Depth 5 | Out-File -FilePath $OutputPath -Encoding UTF8
            Write-Host "数据中心能效报告已保存至：$OutputPath"
        }
        
        return $results
    }
    catch {
        Write-Host "数据中心能效计算失败：$_"
    }
}

这些脚本将帮助您实现绿色计算和能耗优化的关键功能。记住，真正的绿色计算不仅是关于降低功耗，还包括延长硬件生命周期、减少电子垃圾和优化资源利用。通过这些 PowerShell 工具，您可以监控、优化和规划您的 IT 基础设施，使其更加环保和可持续。

发表更新powershell / cloud2 分钟读完 (大约304个字)

PowerShell 技能连载 - 云存储自动化备份方案

在混合云架构中，数据保护是业务连续性的关键。本文演示如何通过PowerShell实现本地数据到云端存储的自动化备份，支持Azure Blob和AWS S3两种主流云存储方案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
function Start-CloudBackup {
    param(
        [string]$LocalPath,
        [ValidateSet('Azure','AWS')]
        [string]$CloudProvider,
        [string]$ContainerName
    )

    try {
        # 压缩本地数据
        $backupFile = "$env:TEMP\backup_$(Get-Date -Format yyyyMMdd).zip"
        Compress-Archive -Path $LocalPath -DestinationPath $backupFile

        # 执行云上传
        switch ($CloudProvider) {
            'Azure' {
                az storage blob upload --account-name $env:AZURE_STORAGE_ACCOUNT \
                    --container $ContainerName \
                    --file $backupFile \
                    --auth-mode key
            }
            'AWS' {
                Write-S3Object -BucketName $ContainerName \
                    -File $backupFile \
                    -Region $env:AWS_REGION
            }
        }

        # 验证备份
        $checksum = (Get-FileHash $backupFile).Hash
        Write-Host "备份完成，校验码：$checksum"
    }
    catch {
        Write-Error "备份失败：$_"
    }
    finally {
        Remove-Item $backupFile -ErrorAction SilentlyContinue
    }
}

实现原理分析：

  1. 采用标准化ZIP格式进行数据压缩打包
  2. 通过云服务商CLI工具实现混合云上传
  3. 哈希校验机制确保备份数据完整性
  4. 临时文件自动清理保障存储空间
  5. 异常处理覆盖网络中断和权限问题

该脚本将备份操作从手动执行转为计划任务驱动，特别适合需要定期保护关键业务数据的金融和电商场景。

发表更新powershell / tip7 分钟读完 (大约980个字)

PowerShell 技能连载 - 容器编排管理

在容器编排领域，管理对于确保容器集群的稳定性和应用服务的可用性至关重要。本文将介绍如何使用PowerShell构建一个容器编排管理系统，包括集群监控、服务管理、资源调度等功能。

集群监控

首先，让我们创建一个用于监控容器集群的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
function Monitor-ContainerCluster {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ClusterID,
        
        [Parameter()]
        [string[]]$ClusterTypes,
        
        [Parameter()]
        [string[]]$MonitorMetrics,
        
        [Parameter()]
        [hashtable]$Thresholds,
        
        [Parameter()]
        [string]$ReportPath,
        
        [Parameter()]
        [switch]$AutoAlert
    )
    
    try {
        $monitor = [PSCustomObject]@{
            ClusterID = $ClusterID
            StartTime = Get-Date
            ClusterStatus = @{}
            Metrics = @{}
            Alerts = @()
        }
        
        # 获取集群信息
        $cluster = Get-ClusterInfo -ClusterID $ClusterID
        
        # 监控集群
        foreach ($type in $ClusterTypes) {
            $monitor.ClusterStatus[$type] = @{}
            $monitor.Metrics[$type] = @{}
            
            foreach ($node in $cluster.Nodes[$type]) {
                $status = [PSCustomObject]@{
                    NodeID = $node.ID
                    Status = "Unknown"
                    Metrics = @{}
                    Health = 0
                    Alerts = @()
                }
                
                # 获取节点指标
                $nodeMetrics = Get-NodeMetrics `
                    -Node $node `
                    -Metrics $MonitorMetrics
                
                $status.Metrics = $nodeMetrics
                
                # 评估节点健康状态
                $health = Calculate-NodeHealth `
                    -Metrics $nodeMetrics `
                    -Thresholds $Thresholds
                
                $status.Health = $health
                
                # 检查节点告警
                $alerts = Check-NodeAlerts `
                    -Metrics $nodeMetrics `
                    -Health $health
                
                if ($alerts.Count -gt 0) {
                    $status.Status = "Warning"
                    $status.Alerts = $alerts
                    $monitor.Alerts += $alerts
                    
                    # 自动告警
                    if ($AutoAlert) {
                        Send-NodeAlerts `
                            -Node $node `
                            -Alerts $alerts
                    }
                }
                else {
                    $status.Status = "Normal"
                }
                
                $monitor.ClusterStatus[$type][$node.ID] = $status
                $monitor.Metrics[$type][$node.ID] = [PSCustomObject]@{
                    Metrics = $nodeMetrics
                    Health = $health
                    Alerts = $alerts
                }
            }
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-ClusterReport `
                -Monitor $monitor `
                -Cluster $cluster
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新监控器状态
        $monitor.EndTime = Get-Date
        
        return $monitor
    }
    catch {
        Write-Error "集群监控失败：$_"
        return $null
    }
}

服务管理

接下来，创建一个用于管理容器服务的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
function Manage-ContainerServices {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ServiceID,
        
        [Parameter()]
        [string[]]$ServiceTypes,
        
        [Parameter()]
        [ValidateSet("Deploy", "Scale", "Update")]
        [string]$OperationMode = "Deploy",
        
        [Parameter()]
        [hashtable]$ServiceConfig,
        
        [Parameter()]
        [string]$LogPath
    )
    
    try {
        $manager = [PSCustomObject]@{
            ServiceID = $ServiceID
            StartTime = Get-Date
            ServiceStatus = @{}
            Operations = @()
            Results = @()
        }
        
        # 获取服务配置
        $config = Get-ServiceConfig -ServiceID $ServiceID
        
        # 管理服务
        foreach ($type in $ServiceTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Operations = @()
                Results = @()
            }
            
            # 应用服务配置
            $typeConfig = Apply-ServiceConfig `
                -Config $config `
                -Type $type `
                -Mode $OperationMode `
                -Settings $ServiceConfig
            
            $status.Config = $typeConfig
            
            # 执行服务操作
            $operations = Execute-ServiceOperations `
                -Type $type `
                -Config $typeConfig
            
            $status.Operations = $operations
            $manager.Operations += $operations
            
            # 验证操作结果
            $results = Validate-ServiceOperations `
                -Operations $operations `
                -Config $typeConfig
            
            $status.Results = $results
            $manager.Results += $results
            
            # 更新服务状态
            if ($results.Success) {
                $status.Status = "Running"
            }
            else {
                $status.Status = "Failed"
            }
            
            $manager.ServiceStatus[$type] = $status
        }
        
        # 记录服务管理日志
        if ($LogPath) {
            $manager | ConvertTo-Json -Depth 10 | Out-File -FilePath $LogPath
        }
        
        # 更新管理器状态
        $manager.EndTime = Get-Date
        
        return $manager
    }
    catch {
        Write-Error "服务管理失败：$_"
        return $null
    }
}

资源调度

最后，创建一个用于管理容器资源调度的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Manage-ContainerScheduling {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ScheduleID,
        
        [Parameter()]
        [string[]]$ResourceTypes,
        
        [Parameter()]
        [ValidateSet("Auto", "Manual", "Hybrid")]
        [string]$SchedulingMode = "Auto",
        
        [Parameter()]
        [hashtable]$SchedulingConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $manager = [PSCustomObject]@{
            ScheduleID = $ScheduleID
            StartTime = Get-Date
            SchedulingStatus = @{}
            Allocations = @{}
            Optimization = @{}
        }
        
        # 获取调度配置
        $config = Get-SchedulingConfig -ScheduleID $ScheduleID
        
        # 管理调度
        foreach ($type in $ResourceTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Allocations = @{}
                Optimization = @{}
            }
            
            # 应用调度配置
            $typeConfig = Apply-SchedulingConfig `
                -Config $config `
                -Type $type `
                -Mode $SchedulingMode `
                -Settings $SchedulingConfig
            
            $status.Config = $typeConfig
            
            # 执行资源分配
            $allocations = Execute-ResourceAllocations `
                -Type $type `
                -Config $typeConfig
            
            $status.Allocations = $allocations
            $manager.Allocations[$type] = $allocations
            
            # 优化资源使用
            $optimization = Optimize-ResourceUsage `
                -Allocations $allocations `
                -Config $typeConfig
            
            $status.Optimization = $optimization
            $manager.Optimization[$type] = $optimization
            
            # 更新调度状态
            if ($optimization.Success) {
                $status.Status = "Optimized"
            }
            else {
                $status.Status = "Warning"
            }
            
            $manager.SchedulingStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-SchedulingReport `
                -Manager $manager `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新管理器状态
        $manager.EndTime = Get-Date
        
        return $manager
    }
    catch {
        Write-Error "资源调度失败：$_"
        return $null
    }
}

使用示例

以下是如何使用这些函数来管理容器编排的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
# 监控容器集群
$monitor = Monitor-ContainerCluster -ClusterID "CLUSTER001" `
    -ClusterTypes @("Master", "Worker", "Storage") `
    -MonitorMetrics @("CPU", "Memory", "Network") `
    -Thresholds @{
        "CPU" = @{
            "MaxUsage" = 80
            "AverageUsage" = 60
            "PeakUsage" = 90
        }
        "Memory" = @{
            "MaxUsage" = 85
            "AverageUsage" = 65
            "PeakUsage" = 95
        }
        "Network" = @{
            "MaxLatency" = 100
            "PacketLoss" = 1
            "Bandwidth" = 1000
        }
    } `
    -ReportPath "C:\Reports\cluster_monitoring.json" `
    -AutoAlert

# 管理容器服务
$manager = Manage-ContainerServices -ServiceID "SERVICE001" `
    -ServiceTypes @("Web", "Database", "Cache") `
    -OperationMode "Deploy" `
    -ServiceConfig @{
        "Web" = @{
            "Replicas" = 3
            "Resources" = @{
                "CPU" = "500m"
                "Memory" = "512Mi"
            }
            "HealthCheck" = $true
        }
        "Database" = @{
            "Replicas" = 2
            "Resources" = @{
                "CPU" = "1000m"
                "Memory" = "1Gi"
            }
            "Persistence" = $true
        }
        "Cache" = @{
            "Replicas" = 2
            "Resources" = @{
                "CPU" = "250m"
                "Memory" = "256Mi"
            }
            "EvictionPolicy" = "LRU"
        }
    } `
    -LogPath "C:\Logs\service_management.json"

# 管理容器资源调度
$scheduler = Manage-ContainerScheduling -ScheduleID "SCHEDULE001" `
    -ResourceTypes @("Compute", "Storage", "Network") `
    -SchedulingMode "Auto" `
    -SchedulingConfig @{
        "Compute" = @{
            "NodeSelector" = @{
                "CPU" = ">=4"
                "Memory" = ">=8Gi"
            }
            "Affinity" = "PreferredDuringScheduling"
            "Tolerations" = @("Critical")
        }
        "Storage" = @{
            "StorageClass" = "SSD"
            "Capacity" = "100Gi"
            "AccessMode" = "ReadWriteMany"
        }
        "Network" = @{
            "ServiceType" = "LoadBalancer"
            "Bandwidth" = "1000Mbps"
            "QoS" = "Guaranteed"
        }
    } `
    -ReportPath "C:\Reports\scheduling_management.json"

最佳实践

  1. 监控集群状态
  2. 管理服务部署
  3. 优化资源调度
  4. 保持详细的运行记录
  5. 定期进行集群检查
  6. 实施资源优化策略
  7. 建立预警机制
  8. 保持系统文档更新
发表更新powershell / tip6 分钟读完 (大约953个字)

PowerShell 技能连载 - Kubernetes 集成

在容器化时代，将PowerShell与Kubernetes集成可以为容器管理带来强大的自动化能力。本文将介绍如何使用PowerShell构建一个Kubernetes管理系统，包括集群管理、应用部署和监控分析等功能。

集群管理

首先，让我们创建一个用于管理Kubernetes集群的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
function Manage-KubernetesCluster {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ClusterID,
        
        [Parameter()]
        [string[]]$ClusterTypes,
        
        [Parameter()]
        [ValidateSet("Create", "Update", "Delete")]
        [string]$OperationMode = "Create",
        
        [Parameter()]
        [hashtable]$ClusterConfig,
        
        [Parameter()]
        [string]$LogPath
    )
    
    try {
        $manager = [PSCustomObject]@{
            ClusterID = $ClusterID
            StartTime = Get-Date
            ClusterStatus = @{}
            Operations = @{}
            Issues = @()
        }
        
        # 获取集群配置
        $config = Get-ClusterConfig -ClusterID $ClusterID
        
        # 管理集群
        foreach ($type in $ClusterTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Operations = @{}
                Issues = @()
            }
            
            # 应用集群配置
            $typeConfig = Apply-ClusterConfig `
                -Config $config `
                -Type $type `
                -Mode $OperationMode `
                -Settings $ClusterConfig
            
            $status.Config = $typeConfig
            
            # 执行集群操作
            $operations = Execute-ClusterOperations `
                -Type $type `
                -Config $typeConfig
            
            $status.Operations = $operations
            $manager.Operations[$type] = $operations
            
            # 检查集群问题
            $issues = Check-ClusterIssues `
                -Operations $operations `
                -Config $typeConfig
            
            $status.Issues = $issues
            $manager.Issues += $issues
            
            # 更新集群状态
            if ($issues.Count -gt 0) {
                $status.Status = "Warning"
            }
            else {
                $status.Status = "Success"
            }
            
            $manager.ClusterStatus[$type] = $status
        }
        
        # 记录集群日志
        if ($LogPath) {
            $manager | ConvertTo-Json -Depth 10 | Out-File -FilePath $LogPath
        }
        
        # 更新管理器状态
        $manager.EndTime = Get-Date
        
        return $manager
    }
    catch {
        Write-Error "集群管理失败：$_"
        return $null
    }
}

应用部署

接下来，创建一个用于管理应用部署的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Deploy-KubernetesApps {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$DeploymentID,
        
        [Parameter()]
        [string[]]$DeploymentTypes,
        
        [Parameter()]
        [ValidateSet("Rolling", "BlueGreen", "Canary")]
        [string]$DeploymentMode = "Rolling",
        
        [Parameter()]
        [hashtable]$DeploymentConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $deployer = [PSCustomObject]@{
            DeploymentID = $DeploymentID
            StartTime = Get-Date
            DeploymentStatus = @{}
            Deployments = @{}
            Actions = @()
        }
        
        # 获取部署配置
        $config = Get-DeploymentConfig -DeploymentID $DeploymentID
        
        # 管理部署
        foreach ($type in $DeploymentTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Deployments = @{}
                Actions = @()
            }
            
            # 应用部署配置
            $typeConfig = Apply-DeploymentConfig `
                -Config $config `
                -Type $type `
                -Mode $DeploymentMode `
                -Settings $DeploymentConfig
            
            $status.Config = $typeConfig
            
            # 部署应用
            $deployments = Deploy-KubernetesResources `
                -Type $type `
                -Config $typeConfig
            
            $status.Deployments = $deployments
            $deployer.Deployments[$type] = $deployments
            
            # 执行部署动作
            $actions = Execute-DeploymentActions `
                -Deployments $deployments `
                -Config $typeConfig
            
            $status.Actions = $actions
            $deployer.Actions += $actions
            
            # 更新部署状态
            if ($actions.Count -gt 0) {
                $status.Status = "Deployed"
            }
            else {
                $status.Status = "Failed"
            }
            
            $deployer.DeploymentStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-DeploymentReport `
                -Deployer $deployer `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新部署器状态
        $deployer.EndTime = Get-Date
        
        return $deployer
    }
    catch {
        Write-Error "应用部署失败：$_"
        return $null
    }
}

监控分析

最后，创建一个用于管理监控分析的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Monitor-KubernetesResources {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$MonitorID,
        
        [Parameter()]
        [string[]]$MonitorTypes,
        
        [Parameter()]
        [ValidateSet("Metrics", "Logs", "Events")]
        [string]$MonitorMode = "Metrics",
        
        [Parameter()]
        [hashtable]$MonitorConfig,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $monitor = [PSCustomObject]@{
            MonitorID = $MonitorID
            StartTime = Get-Date
            MonitorStatus = @{}
            Metrics = @{}
            Alerts = @()
        }
        
        # 获取监控配置
        $config = Get-MonitorConfig -MonitorID $MonitorID
        
        # 管理监控
        foreach ($type in $MonitorTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Metrics = @{}
                Alerts = @()
            }
            
            # 应用监控配置
            $typeConfig = Apply-MonitorConfig `
                -Config $config `
                -Type $type `
                -Mode $MonitorMode `
                -Settings $MonitorConfig
            
            $status.Config = $typeConfig
            
            # 收集监控指标
            $metrics = Collect-KubernetesMetrics `
                -Type $type `
                -Config $typeConfig
            
            $status.Metrics = $metrics
            $monitor.Metrics[$type] = $metrics
            
            # 检查监控告警
            $alerts = Check-MonitorAlerts `
                -Metrics $metrics `
                -Config $typeConfig
            
            $status.Alerts = $alerts
            $monitor.Alerts += $alerts
            
            # 更新监控状态
            if ($alerts.Count -gt 0) {
                $status.Status = "Warning"
            }
            else {
                $status.Status = "Normal"
            }
            
            $monitor.MonitorStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-MonitorReport `
                -Monitor $monitor `
                -Config $config
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新监控器状态
        $monitor.EndTime = Get-Date
        
        return $monitor
    }
    catch {
        Write-Error "监控分析失败：$_"
        return $null
    }
}

使用示例

以下是如何使用这些函数来管理Kubernetes的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
# 管理Kubernetes集群
$manager = Manage-KubernetesCluster -ClusterID "CLUSTER001" `
    -ClusterTypes @("ControlPlane", "Worker", "Storage") `
    -OperationMode "Create" `
    -ClusterConfig @{
        "ControlPlane" = @{
            "Nodes" = 3
            "Resources" = @{
                "CPU" = "4"
                "Memory" = "8Gi"
                "Storage" = "100Gi"
            }
            "HighAvailability" = $true
        }
        "Worker" = @{
            "Nodes" = 5
            "Resources" = @{
                "CPU" = "8"
                "Memory" = "16Gi"
                "Storage" = "200Gi"
            }
            "AutoScaling" = $true
        }
        "Storage" = @{
            "Type" = "PersistentVolume"
            "StorageClass" = "Standard"
            "Replication" = 3
            "Backup" = $true
        }
    } `
    -LogPath "C:\Logs\cluster_management.json"

# 部署Kubernetes应用
$deployer = Deploy-KubernetesApps -DeploymentID "DEPLOYMENT001" `
    -DeploymentTypes @("Deployment", "Service", "Ingress") `
    -DeploymentMode "Rolling" `
    -DeploymentConfig @{
        "Deployment" = @{
            "Replicas" = 3
            "Strategy" = "RollingUpdate"
            "Resources" = @{
                "CPU" = "500m"
                "Memory" = "512Mi"
            }
            "HealthCheck" = $true
        }
        "Service" = @{
            "Type" = "LoadBalancer"
            "Ports" = @(80, 443)
            "Protocol" = "TCP"
            "SessionAffinity" = $true
        }
        "Ingress" = @{
            "Host" = "app.example.com"
            "TLS" = $true
            "Rules" = @{
                "Path" = "/"
                "Service" = "app-service"
            }
        }
    } `
    -ReportPath "C:\Reports\app_deployment.json"

# 监控Kubernetes资源
$monitor = Monitor-KubernetesResources -MonitorID "MONITOR001" `
    -MonitorTypes @("Pods", "Services", "Nodes") `
    -MonitorMode "Metrics" `
    -MonitorConfig @{
        "Pods" = @{
            "Metrics" = @("CPU", "Memory", "Network")
            "Threshold" = 80
            "Interval" = 60
            "Alert" = $true
        }
        "Services" = @{
            "Metrics" = @("Requests", "Latency", "Errors")
            "Threshold" = 90
            "Interval" = 60
            "Alert" = $true
        }
        "Nodes" = @{
            "Metrics" = @("CPU", "Memory", "Disk")
            "Threshold" = 85
            "Interval" = 300
            "Alert" = $true
        }
    } `
    -ReportPath "C:\Reports\resource_monitoring.json"

最佳实践

  1. 实施集群管理
  2. 部署应用服务
  3. 监控资源使用
  4. 保持详细的部署记录
  5. 定期进行健康检查
  6. 实施监控策略
  7. 建立告警机制
  8. 保持系统文档更新
发表更新powershell / tip7 分钟读完 (大约977个字)

PowerShell 技能连载 - 金融交易监控管理

在金融交易领域，监控管理对于确保交易安全性和合规性至关重要。本文将介绍如何使用PowerShell构建一个金融交易监控管理系统，包括交易监控、风险评估、合规检查等功能。

交易监控

首先，让我们创建一个用于监控金融交易的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
function Monitor-FinancialTransactions {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$AccountID,
        
        [Parameter()]
        [string[]]$TransactionTypes,
        
        [Parameter()]
        [string[]]$MonitorMetrics,
        
        [Parameter()]
        [hashtable]$Thresholds,
        
        [Parameter()]
        [string]$ReportPath,
        
        [Parameter()]
        [switch]$AutoAlert
    )
    
    try {
        $monitor = [PSCustomObject]@{
            AccountID = $AccountID
            StartTime = Get-Date
            TransactionStatus = @{}
            Metrics = @{}
            Alerts = @()
        }
        
        # 获取账户信息
        $account = Get-AccountInfo -AccountID $AccountID
        
        # 监控交易
        foreach ($type in $TransactionTypes) {
            $monitor.TransactionStatus[$type] = @{}
            $monitor.Metrics[$type] = @{}
            
            foreach ($transaction in $account.Transactions[$type]) {
                $status = [PSCustomObject]@{
                    TransactionID = $transaction.ID
                    Status = "Unknown"
                    Metrics = @{}
                    Risk = 0
                    Alerts = @()
                }
                
                # 获取交易指标
                $transactionMetrics = Get-TransactionMetrics `
                    -Transaction $transaction `
                    -Metrics $MonitorMetrics
                
                $status.Metrics = $transactionMetrics
                
                # 评估交易风险
                $risk = Calculate-TransactionRisk `
                    -Metrics $transactionMetrics `
                    -Thresholds $Thresholds
                
                $status.Risk = $risk
                
                # 检查交易告警
                $alerts = Check-TransactionAlerts `
                    -Metrics $transactionMetrics `
                    -Risk $risk
                
                if ($alerts.Count -gt 0) {
                    $status.Status = "Warning"
                    $status.Alerts = $alerts
                    $monitor.Alerts += $alerts
                    
                    # 自动告警
                    if ($AutoAlert) {
                        Send-TransactionAlerts `
                            -Transaction $transaction `
                            -Alerts $alerts
                    }
                }
                else {
                    $status.Status = "Normal"
                }
                
                $monitor.TransactionStatus[$type][$transaction.ID] = $status
                $monitor.Metrics[$type][$transaction.ID] = [PSCustomObject]@{
                    Metrics = $transactionMetrics
                    Risk = $risk
                    Alerts = $alerts
                }
            }
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-TransactionReport `
                -Monitor $monitor `
                -Account $account
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新监控器状态
        $monitor.EndTime = Get-Date
        
        return $monitor
    }
    catch {
        Write-Error "交易监控失败：$_"
        return $null
    }
}

风险评估

接下来，创建一个用于评估金融风险的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
function Assess-FinancialRisk {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$RiskID,
        
        [Parameter()]
        [string[]]$RiskTypes,
        
        [Parameter()]
        [ValidateSet("RealTime", "Scheduled", "Manual")]
        [string]$AssessmentMode = "RealTime",
        
        [Parameter()]
        [hashtable]$RiskConfig,
        
        [Parameter()]
        [string]$LogPath
    )
    
    try {
        $assessor = [PSCustomObject]@{
            RiskID = $RiskID
            StartTime = Get-Date
            RiskStatus = @{}
            Assessments = @()
            Mitigations = @()
        }
        
        # 获取风险评估配置
        $config = Get-RiskConfig -RiskID $RiskID
        
        # 评估风险
        foreach ($type in $RiskTypes) {
            $risk = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Config = @{}
                Assessments = @()
                Mitigations = @()
            }
            
            # 应用风险评估配置
            $typeConfig = Apply-RiskConfig `
                -Config $config `
                -Type $type `
                -Mode $AssessmentMode `
                -Settings $RiskConfig
            
            $risk.Config = $typeConfig
            
            # 评估风险
            $assessments = Evaluate-RiskFactors `
                -Type $type `
                -Config $typeConfig
            
            $risk.Assessments = $assessments
            $assessor.Assessments += $assessments
            
            # 生成缓解措施
            $mitigations = Generate-RiskMitigations `
                -Assessments $assessments `
                -Config $typeConfig
            
            $risk.Mitigations = $mitigations
            $assessor.Mitigations += $mitigations
            
            # 验证风险评估结果
            $validation = Validate-RiskAssessment `
                -Assessments $assessments `
                -Mitigations $mitigations
            
            if ($validation.Success) {
                $risk.Status = "Mitigated"
            }
            else {
                $risk.Status = "High"
            }
            
            $assessor.RiskStatus[$type] = $risk
        }
        
        # 记录风险评估日志
        if ($LogPath) {
            $assessor | ConvertTo-Json -Depth 10 | Out-File -FilePath $LogPath
        }
        
        # 更新评估器状态
        $assessor.EndTime = Get-Date
        
        return $assessor
    }
    catch {
        Write-Error "风险评估失败：$_"
        return $null
    }
}

合规检查

最后，创建一个用于检查金融合规性的函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
function Check-FinancialCompliance {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory = $true)]
        [string]$ComplianceID,
        
        [Parameter()]
        [string[]]$ComplianceTypes,
        
        [Parameter()]
        [ValidateSet("AML", "KYC", "GDPR")]
        [string]$Standard = "AML",
        
        [Parameter()]
        [hashtable]$ComplianceRules,
        
        [Parameter()]
        [string]$ReportPath
    )
    
    try {
        $checker = [PSCustomObject]@{
            ComplianceID = $ComplianceID
            StartTime = Get-Date
            ComplianceStatus = @{}
            Violations = @()
            Recommendations = @()
        }
        
        # 获取合规性信息
        $compliance = Get-ComplianceInfo -ComplianceID $ComplianceID
        
        # 检查合规性
        foreach ($type in $ComplianceTypes) {
            $status = [PSCustomObject]@{
                Type = $type
                Status = "Unknown"
                Rules = @{}
                Violations = @()
                Score = 0
            }
            
            # 应用合规性规则
            $rules = Apply-ComplianceRules `
                -Compliance $compliance `
                -Type $type `
                -Standard $Standard `
                -Rules $ComplianceRules
            
            $status.Rules = $rules
            
            # 检查违规
            $violations = Check-ComplianceViolations `
                -Compliance $compliance `
                -Rules $rules
            
            if ($violations.Count -gt 0) {
                $status.Status = "NonCompliant"
                $status.Violations = $violations
                $checker.Violations += $violations
                
                # 生成建议
                $recommendations = Generate-ComplianceRecommendations `
                    -Violations $violations
                
                $checker.Recommendations += $recommendations
            }
            else {
                $status.Status = "Compliant"
            }
            
            # 计算合规性评分
            $score = Calculate-ComplianceScore `
                -Status $status `
                -Rules $rules
            
            $status.Score = $score
            
            $checker.ComplianceStatus[$type] = $status
        }
        
        # 生成报告
        if ($ReportPath) {
            $report = Generate-ComplianceReport `
                -Checker $checker `
                -Compliance $compliance
            
            $report | ConvertTo-Json -Depth 10 | Out-File -FilePath $ReportPath
        }
        
        # 更新检查器状态
        $checker.EndTime = Get-Date
        
        return $checker
    }
    catch {
        Write-Error "合规性检查失败：$_"
        return $null
    }
}

使用示例

以下是如何使用这些函数来管理金融交易监控的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
# 监控金融交易
$monitor = Monitor-FinancialTransactions -AccountID "ACC001" `
    -TransactionTypes @("Payment", "Transfer", "Investment") `
    -MonitorMetrics @("Amount", "Frequency", "Pattern") `
    -Thresholds @{
        "Amount" = @{
            "MaxTransaction" = 100000
            "DailyLimit" = 500000
            "MonthlyLimit" = 5000000
        }
        "Frequency" = @{
            "MaxPerHour" = 10
            "MaxPerDay" = 50
            "MaxPerMonth" = 500
        }
        "Pattern" = @{
            "SuspiciousPatterns" = @("RoundAmount", "MultipleSmall", "HighRiskCountry")
            "RiskScore" = 70
        }
    } `
    -ReportPath "C:\Reports\transaction_monitoring.json" `
    -AutoAlert

# 评估金融风险
$assessor = Assess-FinancialRisk -RiskID "RISK001" `
    -RiskTypes @("Market", "Credit", "Operational") `
    -AssessmentMode "RealTime" `
    -RiskConfig @{
        "Market" = @{
            "Thresholds" = @{
                "Volatility" = 20
                "Liquidity" = 80
                "Correlation" = 0.7
            }
            "AnalysisPeriod" = 3600
            "AlertThreshold" = 3
        }
        "Credit" = @{
            "Thresholds" = @{
                "DefaultRate" = 5
                "Exposure" = 1000000
                "Rating" = "BBB"
            }
            "CheckInterval" = 1800
            "ActionThreshold" = 2
        }
        "Operational" = @{
            "Thresholds" = @{
                "SystemUptime" = 99.9
                "ErrorRate" = 0.1
                "ResponseTime" = 1000
            }
            "MonitorInterval" = 300
            "AlertThreshold" = 1
        }
    } `
    -LogPath "C:\Logs\risk_assessment.json"

# 检查合规性
$checker = Check-FinancialCompliance -ComplianceID "COMP001" `
    -ComplianceTypes @("Transaction", "Customer", "System") `
    -Standard "AML" `
    -ComplianceRules @{
        "Transaction" = @{
            "MonitoringRequired" = $true
            "ReportingThreshold" = 10000
            "RecordRetention" = 5
        }
        "Customer" = @{
            "KYCRequired" = $true
            "VerificationLevel" = "Enhanced"
            "UpdateFrequency" = 12
        }
        "System" = @{
            "AuditRequired" = $true
            "AccessControl" = "Strict"
            "DataProtection" = "Encrypted"
        }
    } `
    -ReportPath "C:\Reports\compliance_check.json"

最佳实践

  1. 监控交易活动
  2. 评估金融风险
  3. 检查合规性
  4. 保持详细的运行记录
  5. 定期进行风险评估
  6. 实施合规策略
  7. 建立预警机制
  8. 保持系统文档更新
发表更新powershell / tip5 分钟读完 (大约732个字)

PowerShell 技能连载 - XML 数据处理技巧

在 PowerShell 中处理 XML 数据是一项常见任务，特别是在处理配置文件或与 Web 服务交互时。本文将介绍一些实用的 XML 处理技巧。

首先，让我们看看如何创建和读取 XML 数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 创建 XML 文档
$xmlContent = @"
<?xml version="1.0" encoding="UTF-8"?>
<配置>
    <系统设置>
        <服务器>
            <名称>主服务器</名称>
            <IP地址>192.168.1.100</IP地址>
            <端口>8080</端口>
        </服务器>
        <数据库>
            <类型>MySQL</类型>
            <连接字符串>Server=localhost;Database=testdb;User=admin</连接字符串>
        </数据库>
    </系统设置>
    <用户列表>
        <用户>
            <ID>1</ID>
            <姓名>张三</姓名>
            <角色>管理员</角色>
        </用户>
        <用户>
            <ID>2</ID>
            <姓名>李四</姓名>
            <角色>普通用户</角色>
        </用户>
    </用户列表>
</配置>
"@

# 将 XML 字符串转换为 XML 对象
$xml = [xml]$xmlContent

# 访问 XML 数据
$serverName = $xml.配置.系统设置.服务器.名称
$dbType = $xml.配置.系统设置.数据库.类型
Write-Host "服务器名称：$serverName"
Write-Host "数据库类型：$dbType"

使用 XPath 查询 XML 数据：

1
2
3
4
5
6
7
8
9
10
11
12
# 使用 XPath 查询特定用户
$adminUser = $xml.SelectSingleNode("//用户[角色='管理员']")
Write-Host "`n管理员信息："
Write-Host "姓名：$($adminUser.姓名)"
Write-Host "ID：$($adminUser.ID)"

# 查询所有用户
$allUsers = $xml.SelectNodes("//用户")
Write-Host "`n所有用户列表："
foreach ($user in $allUsers) {
    Write-Host "姓名：$($user.姓名), 角色：$($user.角色)"
}

修改 XML 数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 添加新用户
$newUser = $xml.CreateElement("用户")
$newUser.InnerXml = @"
    <ID>3</ID>
    <姓名>王五</姓名>
    <角色>普通用户</角色>
"@
$xml.配置.用户列表.AppendChild($newUser)

# 修改现有数据
$xml.配置.系统设置.服务器.端口 = "9090"

# 保存修改后的 XML
$xml.Save("config.xml")

处理 XML 属性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 创建带有属性的 XML
$xmlWithAttributes = @"
<?xml version="1.0" encoding="UTF-8"?>
<系统>
    <服务 名称="Web服务" 状态="运行中">
        <配置 版本="1.0" 环境="生产">
            <参数 类型="字符串">测试值</参数>
        </配置>
    </服务>
</系统>
"@

$xmlDoc = [xml]$xmlWithAttributes

# 访问属性
$serviceName = $xmlDoc.系统.服务.名称
$serviceStatus = $xmlDoc.系统.服务.状态
Write-Host "`n服务信息："
Write-Host "名称：$serviceName"
Write-Host "状态：$serviceStatus"

一些实用的 XML 处理技巧：

  1. 使用 XML 命名空间：
1
2
3
4
5
6
7
8
9
10
11
12
13
$xmlWithNamespace = @"
<?xml version="1.0" encoding="UTF-8"?>
<ns:系统 xmlns:ns="http://example.com/ns">
    <ns:服务>测试服务</ns:服务>
</ns:系统>
"@

$xmlNs = [xml]$xmlWithNamespace
$nsManager = New-Object System.Xml.XmlNamespaceManager($xmlNs.NameTable)
$nsManager.AddNamespace("ns", "http://example.com/ns")

$service = $xmlNs.SelectSingleNode("//ns:服务", $nsManager)
Write-Host "`n带命名空间的服务：$($service.InnerText)"
  1. 验证 XML 格式：
1
2
3
4
5
6
7
8
9
10
function Test-XmlFormat {
    param([string]$XmlString)
    try {
        [xml]$XmlString | Out-Null
        return $true
    }
    catch {
        return $false
    }
}
  1. 处理大型 XML 文件：
1
2
3
4
5
6
7
8
9
10
11
12
# 使用 XmlReader 处理大型 XML 文件
$reader = [System.Xml.XmlReader]::Create("large-data.xml")
while ($reader.Read()) {
    if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element) {
        if ($reader.Name -eq "用户") {
            $userXml = $reader.ReadOuterXml()
            $user = [xml]$userXml
            Write-Host "处理用户：$($user.用户.姓名)"
        }
    }
}
$reader.Close()

这些技巧将帮助您更有效地处理 XML 数据。记住，在处理大型 XML 文件时，考虑使用流式处理方法来优化内存使用。同时，始终注意 XML 文档的有效性和安全性。

发表更新powershell / tip8 分钟读完 (大约1190个字)

PowerShell 技能连载 - 零信任安全架构实现

在现代网络安全中，零信任架构是一种重要的安全模型，本文将介绍如何使用 PowerShell 实现零信任安全架构的关键组件。

首先，让我们看看如何使用 PowerShell 进行设备健康状态评估：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
# 创建设备健康状态评估函数
function Test-DeviceHealth {
    param(
        [string]$ComputerName = $env:COMPUTERNAME,
        [switch]$IncludeFirewall,
        [switch]$IncludeAntivirus,
        [switch]$IncludeUpdates,
        [string]$OutputPath
    )
    
    try {
        $results = @{}
        
        # 系统信息
        $systemInfo = Get-CimInstance -ComputerName $ComputerName -ClassName Win32_OperatingSystem | 
            Select-Object Caption, Version, LastBootUpTime
        $results.SystemInfo = $systemInfo
        
        # 防火墙状态
        if ($IncludeFirewall) {
            $firewallProfiles = Get-NetFirewallProfile -CimSession $ComputerName
            $results.FirewallStatus = $firewallProfiles | ForEach-Object {
                [PSCustomObject]@{
                    Profile = $_.Name
                    Enabled = $_.Enabled
                    DefaultInboundAction = $_.DefaultInboundAction
                    DefaultOutboundAction = $_.DefaultOutboundAction
                }
            }
        }
        
        # 防病毒状态
        if ($IncludeAntivirus) {
            $antivirusProducts = Get-CimInstance -Namespace root/SecurityCenter2 -ClassName AntivirusProduct -ComputerName $ComputerName
            $results.AntivirusStatus = $antivirusProducts | ForEach-Object {
                [PSCustomObject]@{
                    Name = $_.DisplayName
                    ProductState = $_.ProductState
                    IsEnabled = ($_.ProductState -band 0x1000) -eq 0x1000
                    IsUpToDate = ($_.ProductState -band 0x10) -eq 0
                }
            }
        }
        
        # 更新状态
        if ($IncludeUpdates) {
            $session = New-CimSession -ComputerName $ComputerName
            $updates = Get-WindowsUpdate -CimSession $session
            $results.UpdateStatus = [PSCustomObject]@{
                PendingUpdatesCount = $updates.Count
                SecurityUpdatesCount = ($updates | Where-Object { $_.Categories -match "Security" }).Count
                CriticalUpdatesCount = ($updates | Where-Object { $_.MsrcSeverity -eq "Critical" }).Count
            }
        }
        
        $healthScore = 0
        $maxScore = 0
        
        # 计算健康分数
        if ($IncludeFirewall) {
            $maxScore += 10
            $enabledProfiles = ($results.FirewallStatus | Where-Object { $_.Enabled -eq $true }).Count
            $healthScore += ($enabledProfiles / 3) * 10
        }
        
        if ($IncludeAntivirus) {
            $maxScore += 10
            $avEnabled = ($results.AntivirusStatus | Where-Object { $_.IsEnabled -eq $true }).Count -gt 0
            $avUpToDate = ($results.AntivirusStatus | Where-Object { $_.IsUpToDate -eq $true }).Count -gt 0
            
            if ($avEnabled) { $healthScore += 5 }
            if ($avUpToDate) { $healthScore += 5 }
        }
        
        if ($IncludeUpdates) {
            $maxScore += 10
            $pendingUpdates = $results.UpdateStatus.PendingUpdatesCount
            $criticalUpdates = $results.UpdateStatus.CriticalUpdatesCount
            
            if ($pendingUpdates -eq 0) {
                $healthScore += 10
            } else {
                $healthScore += [Math]::Max(0, 10 - ($criticalUpdates * 2) - ($pendingUpdates * 0.5))
            }
        }
        
        $results.HealthScore = [Math]::Round(($healthScore / $maxScore) * 100)
        $results.ComplianceStatus = $results.HealthScore -ge 70
        $results.AssessmentTime = Get-Date
        
        if ($OutputPath) {
            $results | ConvertTo-Json -Depth 5 | Out-File -FilePath $OutputPath -Encoding UTF8
            Write-Host "设备健康状态已保存至：$OutputPath"
        }
        
        return [PSCustomObject]$results
    }
    catch {
        Write-Host "设备健康状态评估失败：$_"
    }
}

实现条件访问策略：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# 创建条件访问策略函数
function New-ConditionalAccessPolicy {
    param(
        [string]$PolicyName,
        [ValidateSet('AllUsers', 'SelectedUsers', 'SelectedGroups')]
        [string]$UserScope,
        [string[]]$Users,
        [string[]]$Groups,
        [string[]]$Applications,
        [ValidateSet('DeviceCompliance', 'UserRisk', 'SignInRisk', 'Location')]
        [string[]]$Conditions,
        [hashtable]$ConditionValues,
        [ValidateSet('Block', 'Grant', 'SessionControl')]
        [string]$AccessControl,
        [hashtable]$ControlSettings
    )
    
    try {
        $policy = [PSCustomObject]@{
            PolicyName = $PolicyName
            UserScope = $UserScope
            Users = $Users
            Groups = $Groups
            Applications = $Applications
            Conditions = $Conditions
            ConditionValues = $ConditionValues
            AccessControl = $AccessControl
            ControlSettings = $ControlSettings
            CreatedAt = Get-Date
            CreatedBy = $env:USERNAME
        }
        
        # 这里将连接到 Microsoft Graph API 创建实际策略
        # 下面为模拟实现
        $jsonPolicy = $policy | ConvertTo-Json -Depth 5
        Write-Host "已创建条件访问策略：$PolicyName"
        
        return $policy
    }
    catch {
        Write-Host "条件访问策略创建失败：$_"
    }
}

实现安全会话控制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 创建安全会话控制函数
function Set-SecureSessionControl {
    param(
        [string]$SessionId,
        [int]$SessionTimeout = 3600,
        [switch]$EnableScreenLock,
        [int]$ScreenLockTimeout = 300,
        [switch]$RestrictFileDownload,
        [switch]$RestrictClipboard,
        [switch]$EnableWatermark
    )
    
    try {
        $sessionControl = [PSCustomObject]@{
            SessionId = $SessionId
            SessionTimeout = $SessionTimeout
            EnableScreenLock = $EnableScreenLock
            ScreenLockTimeout = $ScreenLockTimeout
            RestrictFileDownload = $RestrictFileDownload
            RestrictClipboard = $RestrictClipboard
            EnableWatermark = $EnableWatermark
            AppliedAt = Get-Date
            AppliedBy = $env:USERNAME
        }
        
        # 这里将应用到实际会话
        # 下面为模拟实现
        $jsonSessionControl = $sessionControl | ConvertTo-Json
        Write-Host "已应用会话控制策略到会话：$SessionId"
        
        return $sessionControl
    }
    catch {
        Write-Host "安全会话控制应用失败：$_"
    }
}

持续监控和评估：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# 创建持续监控函数
function Start-ZeroTrustMonitoring {
    param(
        [string[]]$ComputerNames,
        [int]$Interval = 3600,
        [int]$Duration = 86400,
        [string]$OutputPath
    )
    
    try {
        $startTime = Get-Date
        $endTime = $startTime.AddSeconds($Duration)
        $monitoringResults = @()
        
        while ((Get-Date) -lt $endTime) {
            foreach ($computer in $ComputerNames) {
                $deviceHealth = Test-DeviceHealth -ComputerName $computer -IncludeFirewall -IncludeAntivirus -IncludeUpdates
                
                $monitoringResult = [PSCustomObject]@{
                    Timestamp = Get-Date
                    ComputerName = $computer
                    HealthScore = $deviceHealth.HealthScore
                    ComplianceStatus = $deviceHealth.ComplianceStatus
                    Details = $deviceHealth
                }
                
                $monitoringResults += $monitoringResult
                
                # 如果设备不合规，触发通知
                if (-not $deviceHealth.ComplianceStatus) {
                    Write-Host "设备不合规警告：$computer 的健康分数为 $($deviceHealth.HealthScore)"
                    # 这里可以添加通知逻辑，如发送电子邮件或触发警报
                }
            }
            
            if ((Get-Date).AddSeconds($Interval) -gt $endTime) {
                break
            }
            
            Start-Sleep -Seconds $Interval
        }
        
        if ($OutputPath) {
            $monitoringResults | ConvertTo-Json -Depth 5 | Out-File -FilePath $OutputPath -Encoding UTF8
            Write-Host "监控结果已保存至：$OutputPath"
        }
        
        return $monitoringResults
    }
    catch {
        Write-Host "零信任监控失败：$_"
    }
}

创建安全事件响应：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
# 创建安全事件响应函数
function Invoke-ZeroTrustResponse {
    param(
        [string]$ComputerName,
        [ValidateSet('IsolateDevice', 'ForceUpdate', 'DisableAccount', 'ResetPassword', 'TerminateSession')]
        [string]$Action,
        [hashtable]$ActionParameters,
        [switch]$ForceAction
    )
    
    try {
        $responseLog = [PSCustomObject]@{
            Timestamp = Get-Date
            ComputerName = $ComputerName
            Action = $Action
            ActionParameters = $ActionParameters
            InitiatedBy = $env:USERNAME
            Status = "Initiated"
        }
        
        switch ($Action) {
            'IsolateDevice' {
                # 隔离设备网络
                if ($ForceAction) {
                    $isolationRule = "Block All Inbound and Outbound"
                } else {
                    $isolationRule = "Block All Inbound, Allow Outbound to Management"
                }
                
                # 这里添加实际隔离逻辑
                $responseLog.Status = "Completed"
                $responseLog.Details = "Device isolated with rule: $isolationRule"
            }
            'ForceUpdate' {
                # 强制更新设备
                $session = New-CimSession -ComputerName $ComputerName
                Install-WindowsUpdate -CimSession $session -AcceptAll -AutoReboot
                
                $responseLog.Status = "Completed"
                $responseLog.Details = "Updates initiated, reboot may be required"
            }
            'DisableAccount' {
                # 禁用用户账户
                $username = $ActionParameters.Username
                if (-not $username) {
                    throw "Username required for DisableAccount action"
                }
                
                Disable-LocalUser -Name $username -ComputerName $ComputerName
                
                $responseLog.Status = "Completed"
                $responseLog.Details = "Account $username disabled"
            }
            'ResetPassword' {
                # 重置用户密码
                $username = $ActionParameters.Username
                if (-not $username) {
                    throw "Username required for ResetPassword action"
                }
                
                $newPassword = [System.Web.Security.Membership]::GeneratePassword(16, 4)
                $securePassword = ConvertTo-SecureString -String $newPassword -AsPlainText -Force
                
                Set-LocalUser -Name $username -Password $securePassword -ComputerName $ComputerName
                
                $responseLog.Status = "Completed"
                $responseLog.Details = "Password reset for $username"
            }
            'TerminateSession' {
                # 终止用户会话
                $sessionId = $ActionParameters.SessionId
                if (-not $sessionId) {
                    throw "SessionId required for TerminateSession action"
                }
                
                # 这里添加终止会话逻辑
                $responseLog.Status = "Completed"
                $responseLog.Details = "Session $sessionId terminated"
            }
        }
        
        return $responseLog
    }
    catch {
        Write-Host "零信任响应操作失败：$_"
        return [PSCustomObject]@{
            Timestamp = Get-Date
            ComputerName = $ComputerName
            Action = $Action
            Status = "Failed"
            Error = $_.ToString()
        }
    }
}

这些脚本将帮助您实现零信任安全架构的关键组件。记住，零信任是一种安全模型，而不仅仅是一组技术工具。在实施这些技术时，建议与组织的安全策略结合，并确保遵循”最小权限原则”和”默认拒绝”的理念。同时，完整的零信任架构还需要结合其他安全技术，如多因素认证和微分段。

发表更新powershell / tip5 分钟读完 (大约780个字)

PowerShell 技能连载 - 针对Windows服务器的4种强大的PowerShell安全技术

简介

在不断发展的网络安全领域中，加固您的Windows服务器不仅是最佳实践，而且是必要的。PowerShell凭借其多功能性和自动化能力，在确保服务器安全的神奇旅程中成为我们可靠的魔杖。让我们讨论一下4种PowerShell安全技术，这将有助于实现我们的目标。

PowerShell安全性: 使用PowerShell进行审计

使用POSH-Sysmon配置Sysmon

Sysmon: 沉默的哨兵

由微软开发的Sysmon是一个强大的工具，用于监视系统并添加细粒度事件以便即使在重启后也能被跟踪。

这就像拥有一把神奇的放大镜，可以揭示服务器上隐藏的活动。

为什么使用POSH-Sysmon?

POSH-Sysmon是一个简化配置Sysmon 的PowerShell脚本。

它让您可以轻松地使用PowerShell创建和管理 Sysinternals Sysmon v2.0 配置文件。

通过Sysmon，您可以跟踪与进程创建、网络连接、注册表更改等相关的事件。

示例: 检测凭证提取尝试

要追踪最关键的事件之一——恶意进程尝试从内存中提取凭据时，

请使用 ProcessAccess 过滤器来检测Local Security Authority Subsystem Service (LSASS) 中此类尝试：

1
Get-WinEvent -LogName 'Microsoft-Windows-Sysmon/Operational' | Where-Object {$_.EventID -eq 10 -and $_.Message -like '*LSASS*'}

强化您的电子邮件堡垒：客户端规则转发阻止控制

为什么这很重要？

攻击者经常利用Office 365，在Outlook中设置静默规则，将敏感电子邮件转发到他们的账户。

通过启用客户端规则转发阻止控制来加强您的电子邮件安全性。

PowerShell操作:

使用PowerShell启用转发阻止：

1
Set-OrganizationConfig -RulesQuota 0

使用DSC进行PowerShell安全配置

什么是PowerShell DSC?

期望状态配置（DSC）就像一种魔法咒语，确保您的服务器保持安全配置。

它允许您定义和强制执行Windows服务器的期望状态。

示例：根据CIS基准进行安全配置

使用PowerShell DSC根据CIS Microsoft Windows Server 2019或Azure Secure Center Baseline for Windows Server 2016等基准应用安全配置。

您的DSC代码成为了您的护身符：

1
2
3
4
5
6
7
8
9
Configuration SecureServer {
    Import-DscResource -ModuleName SecurityPolicyDsc
    Node 'localhost' {
        SecurityPolicy 'Audit - Audit account logon events' {
            PolicySetting = 'Success,Failure'
        }
        # 更多安全设置在此处...
    }
}

HardeningKitty：Windows配置的猫护卫

小猫在忙什么？

HardeningKitty，我们的猫友，会自动检查和评估Windows系统的硬化。

它还会检查像Microsoft Office和Microsoft Edge这样的单个应用程序。

PowerShell完美性：

运行HardeningKitty来评估您系统的安全姿态：

1
.\HardeningKitty.ps1 -AuditSystem

结论

通过使用PowerShell，我们施展了审计、保护和加固我们的Windows服务器。记住，安全是一个持续不断的追求 —— 让你的咒语锋利，让你的PowerShell脚本更加精湛！

关注我

链接

PowerShell 技术 QQ 群
PowerShell 技术 QQ 群

最新文章

归档

标签

powershell2360
tip2264
powertip2264
series2264
scripting78
best-practices73
automation66
azure60
security59
devops45
system-management41
tooling39
monitoring39
script38
web31
network31
geek30
text-processing25
cloud22
container21
ai21
windows20
data-format20
identity19
performance16
config-management16
package-management15
database11
testing11
qq10
office10
remoting10
reporting9
linux8
cross-platform8
data-processing8
virtualization5
microsoft4
troubleshooting4
command3
wmi3
cim3
streaming3
storage3
video2
macos2
site-management2
patterns2
inventory2
module2

分类

×