Använda SQL Assessment API för SQL Server i Linux

2025-03-05

gäller för:SQL Server – Linux

SQL Assessment API tillhandahåller en mekanism för att utvärdera konfigurationen av SQL Server för bästa praxis. API:et levereras med en regeluppsättning som innehåller metodtips som rekommenderas av SQL Server-teamet. Den här regeluppsättningen utökas med lanseringen av nya versioner. Det är användbart att se till att SQL Server-konfigurationen är i linje med de rekommenderade metodtipsen.

Microsofts levererade regeluppsättning är tillgänglig på GitHub. Du kan visa hela regeluppsättningen på lagringsplatsen exempel.

I den här artikeln tittar vi på två sätt att köra SQL Assessment API för SQL Server på Linux och containrar:

SQL-utvärderingstillägg för Azure Data Studio (förhandsversion)
SQL Assessment API med PowerShell

SQL-utvärderingstillägg för Azure Data Studio (förhandsversion)

SQL Assessment-tillägget för Azure Data Studio (förhandsversion) ger en mekanism för att utvärdera konfigurationen av SQL Server för bästa praxis.

Med den här förhandsversionen kan du:

Utvärdera en SQL Server, Azure SQL-databas eller Azure SQL Managed Instance och dess databaser med inbyggda regler
Hämta en lista över alla inbyggda regler som gäller för en instans och dess databaser
Exportera utvärderingsresultat och listan över tillämpliga regler som ett skript för att lagra det i en SQL-tabell
Skapa HTML-rapporter om utvärderingsresultat

Starta en SQL-utvärdering

När du har installerat SQL Assessment-tillägget expanderar du serverlistan, högerklickar på en server eller databas som du vill utvärdera och väljer Hantera.
I avsnittet Allmänt väljer du sedan SQL-utvärdering. På fliken Utvärdering väljer du Anropa utvärdering för att utföra utvärderingen av den valda SQL Server- eller Azure SQL-databasen. När resultaten är tillgängliga kan du använda filtrerings- och sorteringsfunktionerna.
Välj Exportera som skript för att få resultatet i ett insert-into-table-format. Du kan också välja Skapa HTML-rapport för att spara utvärderingsresultaten som en HTML-fil. Vissa utvärderingsregler är avsedda för vissa SQL Server-konfigurationer och vissa för andra. Detsamma gäller för databasregler. Det finns till exempel regler som endast gäller för SQL Server 2016 (13.x) eller tempdb-databasen.
Knappen Visa tillämpliga regler visar de utvärderingsregler som används för att utvärdera dina servrar och databaser när du har valt Invoke Assessment. Om du vill visa information om SQL Server och SQL Assessment API väljer du Info. Utvärderingssessionsresultat kan granskas på fliken Historik.

SQL Assessment API med PowerShell

Ett annat alternativ är att använda PowerShell för att köra SQL Assessment API-skriptet.

Förutsättningar

Kontrollera att du installera PowerShell på Linux.
Installera SqlServer PowerShell-modulen från PowerShell-galleriet genom att vara inloggad som användare mssql.
```
su mssql -c "/usr/bin/pwsh -Command Install-Module SqlServer"
```

Konfigurera utvärderingen

SQL Assessment API-utdata är tillgängliga i JSON-format. Du måste utföra följande steg för att konfigurera SQL Assessment-API:et på följande sätt:

I den instans som du vill utvärdera skapar du en inloggning för SQL Server-utvärderingar med sql-autentisering. Du kan använda följande Transact-SQL-skript (T-SQL) för att skapa en inloggning och ett starkt lösenord. Lösenordet bör följa SQL Server-standardprincipen för lösenord. Lösenordet måste som standard vara minst åtta tecken långt och innehålla tecken från tre av följande fyra uppsättningar: versaler, gemener, bas-10 siffror och symboler. Lösenord kan vara upp till 128 tecken långa. Använd lösenord som är så långa och komplexa som möjligt.
```
USE [master];
GO

CREATE LOGIN [assessmentLogin]
    WITH PASSWORD = N'<password>';

ALTER SERVER ROLE [CONTROL SERVER] ADD MEMBER [assessmentLogin];
GO
```
Den CONTROL SERVER rollen fungerar för de flesta utvärderingarna. Det finns dock några utvärderingar som kan behöva sysadmin privilegier. Om du inte kör dessa regler rekommenderar vi att du använder CONTROL SERVER behörigheter.
Lagra autentiseringsuppgifterna för inloggning i systemet på följande sätt och ersätt återigen <password> med lösenordet som du använde i föregående steg.
```
echo "assessmentLogin" > /var/opt/mssql/secrets/assessment
echo "<password>" >> /var/opt/mssql/secrets/assessment
```
Skydda de nya autentiseringsuppgifterna för utvärdering genom att se till att endast den mssql användaren kan komma åt autentiseringsuppgifterna.
```
chmod 600 /var/opt/mssql/secrets/assessment
chown mssql:mssql /var/opt/mssql/secrets/assessment
```

Ladda ned utvärderingsskriptet

Följande är ett exempelskript som anropar SQL Assessment-API:et med hjälp av de autentiseringsuppgifter som skapades i föregående steg. Skriptet genererar en utdatafil i JSON-format på den här platsen: /var/opt/mssql/log/assessments.

Not

SQL Assessment API kan också generera utdata i CSV- och XML-format.

Det här skriptet är tillgängligt för nedladdning från GitHub.

Du kan spara filen som /opt/mssql/bin/runassessment.ps1.

[CmdletBinding()] param ()

$Error.Clear()

# Create output directory if not exists

$outDir = '/var/opt/mssql/log/assessments'
if (-not ( Test-Path $outDir )) { mkdir $outDir }
$outPath = Join-Path $outDir 'assessment-latest'

$errorPath = Join-Path $outDir 'assessment-latest-errors'
if ( Test-Path $errorPath ) { remove-item $errorPath }

function ConvertTo-LogOutput {
    [CmdletBinding()]
    param (
        [Parameter(ValueFromPipeline = $true)]
        $input
    )
    process {
        switch ($input) {
            { $_ -is [System.Management.Automation.WarningRecord] } {
                $result = @{
                    'TimeStamp' = $(Get-Date).ToString("O");
                    'Warning'   = $_.Message
                }
            }
            default {
                $result = @{
                    'TimeStamp'      = $input.TimeStamp;
                    'Severity'       = $input.Severity;
                    'TargetType'     = $input.TargetType;
                    'ServerName'     = $serverName;
                    'HostName'       = $hostName;
                    'TargetName'     = $input.TargetObject.Name;
                    'TargetPath'     = $input.TargetPath;
                    'CheckId'        = $input.Check.Id;
                    'CheckName'      = $input.Check.DisplayName;
                    'Message'        = $input.Message;
                    'RulesetName'    = $input.Check.OriginName;
                    'RulesetVersion' = $input.Check.OriginVersion.ToString();
                    'HelpLink'       = $input.HelpLink
                }

                if ( $input.TargetType -eq 'Database') {
                    $result['AvailabilityGroup'] = $input.TargetObject.AvailabilityGroupName
                }
            }
        }

        $result
    }
}

function Get-TargetsRecursive {

    [CmdletBinding()]
    Param (
        [Parameter(ValueFromPipeline = $true)]
        [Microsoft.SqlServer.Management.Smo.Server] $server
    )

    $server
    $server.Databases
}

function Get-ConfSetting {
    [CmdletBinding()]
    param (
        $confFile,
        $section,
        $name,
        $defaultValue = $null
    )

    $inSection = $false

    switch -regex -file $confFile {
        "^\s*\[\s*(.+?)\s*\]" {
            $inSection = $matches[1] -eq $section
        }
        "^\s*$($name)\s*=\s*(.+?)\s*$" {
            if ($inSection) {
                return $matches[1]
            }
        }
    }

    return $defaultValue
}

try {
    Write-Verbose "Acquiring credentials"

    $login, $pwd = Get-Content '/var/opt/mssql/secrets/assessment' -Encoding UTF8NoBOM -TotalCount 2
    $securePassword = ConvertTo-SecureString $pwd -AsPlainText -Force
    $credential = New-Object System.Management.Automation.PSCredential ($login, $securePassword)
    $securePassword.MakeReadOnly()

    Write-Verbose "Acquired credentials"

    $serverInstance = '.'

    if (Test-Path /var/opt/mssql/mssql.conf) {
        $port = Get-ConfSetting /var/opt/mssql/mssql.conf network tcpport

        if (-not [string]::IsNullOrWhiteSpace($port)) {
            Write-Verbose "Using port $($port)"
            $serverInstance = "$($serverInstance),$($port)"
        }
    }

    # IMPORTANT: If the script is run in trusted environments and there is a prelogin handshake error,
    # add -TrustServerCertificate flag in the commands for $serverName, $hostName and Get-SqlInstance lines below.
    $serverName = (Invoke-SqlCmd -ServerInstance $serverInstance -Credential $credential -Query "SELECT @@SERVERNAME")[0]
    $hostName = (Invoke-SqlCmd -ServerInstance $serverInstance -Credential $credential -Query "SELECT HOST_NAME()")[0]

    # Invoke assessment and store results.
    # Replace 'ConvertTo-Json' with 'ConvertTo-Csv' to change output format.
    # Available output formats: JSON, CSV, XML.
    # Encoding parameter is optional.

    Get-SqlInstance -ServerInstance $serverInstance -Credential $credential -ErrorAction Stop
    | Get-TargetsRecursive
    | ForEach-Object { Write-Verbose "Invoke assessment on $($_.Urn)"; $_ }
    | Invoke-SqlAssessment 3>&1
    | ConvertTo-LogOutput
    | ConvertTo-Json -AsArray
    | Set-Content $outPath -Encoding UTF8NoBOM
}
finally {
    Write-Verbose "Error count: $($Error.Count)"

    if ($Error) {
        $Error
        | ForEach-Object { @{ 'TimeStamp' = $(Get-Date).ToString("O"); 'Message' = $_.ToString() } }
        | ConvertTo-Json -AsArray
        | Set-Content $errorPath -Encoding UTF8NoBOM
    }
}

Not

När du kör det här skriptet i betrodda miljöer och får ett handskakningsfel för prelogin lägger du till flaggan -TrustServerCertificate i kommandona för $serverName, $hostName och Get-SqlInstance rader i koden.

Kör utvärderingen

Kontrollera att skriptet ägs och kan köras av mssql.

chown mssql:mssql /opt/mssql/bin/runassessment.ps1
chmod 700 /opt/mssql/bin/runassessment.ps1

Skapa loggmapp och tilldela lämpliga behörigheter till den mssql användaren i mappen:

mkdir /var/opt/mssql/log/assessments/
chown mssql:mssql /var/opt/mssql/log/assessments/
chmod 0700 /var/opt/mssql/log/assessments/

Nu kan du skapa din första utvärdering, men se till att du gör det som mssql användare, så att efterföljande utvärderingar kan köras automatiskt via cron eller systemd säkrare.
```
su mssql -c "pwsh -File /opt/mssql/bin/runassessment.ps1"
```
När kommandot har slutförts genereras utdata i JSON-format. Dessa utdata kan integreras med alla verktyg som stöder parsning av JSON-filer. Ett sådant exempelverktyg är Red Hat Insights.

Feedback

Var den här sidan till hjälp?