Delen via


SQL Assessment-API gebruiken voor SQL Server in Linux

Van toepassing op:SQL Server op Linux

De SQL Assessment-API biedt een mechanisme voor het evalueren van de configuratie van SQL Server voor best practices. De API wordt geleverd met een regelset met aanbevolen procedures van het SQL Server-team. Deze regelset is verbeterd met de release van nieuwe versies. Het is nuttig om te controleren of uw SQL Server-configuratie in overeenstemming is met de aanbevolen procedures.

De verzonden regelset van Microsoft is beschikbaar op GitHub. U kunt de hele regelset bekijken in de opslagplaats met voorbeelden.

In dit artikel bekijken we twee manieren om de SQL Assessment-API voor SQL Server op Linux en containers uit te voeren:

SQL Assessment-extensie voor Azure Data Studio (preview)

De SQL Assessment-extensie voor Azure Data Studio (preview) biedt een mechanisme voor het evalueren van de configuratie van SQL Server voor aanbevolen procedures.

Met deze preview-versie kunt u het volgende doen:

  • Een SQL Server, Azure SQL-database of Azure SQL Managed Instance en de bijbehorende databases evalueren, met ingebouwde regels
  • Een lijst ophalen met alle ingebouwde regels die van toepassing zijn op een exemplaar en de bijbehorende databases
  • Evaluatieresultaten en de lijst met toepasselijke regels exporteren als een script om deze op te slaan in een SQL-tabel
  • HTML-rapporten maken over evaluatieresultaten

Schermopname van de SQL Assessment-extensie in Azure Data Studio.

Een SQL-evaluatie starten

  • Nadat u de SQL Assessment-extensie hebt geïnstalleerd, vouwt u de lijst met servers uit, klikt u met de rechtermuisknop op een server of database die u wilt evalueren en selecteert u Beheren.
  • Selecteer daarna SQL Assessment in de sectie Algemeen. Selecteer Evaluatie aanroepen op het tabblad Evaluatie om de evaluatie uit te voeren van de geselecteerde SQL Server- of Azure SQL-database. Zodra de resultaten beschikbaar zijn, kunt u de filter- en sorteerfuncties gebruiken.
  • Selecteer Exporteren als script om de resultaten in een invoegen in tabel-indeling op te halen. U kunt ook HTML-rapport maken selecteren om de evaluatieresultaten op te slaan als een HTML-bestand. Sommige evaluatieregels zijn bedoeld voor bepaalde SQL Server-configuraties en sommige voor andere. Hetzelfde geldt voor databaseregels. Er zijn bijvoorbeeld regels die alleen van toepassing zijn op SQL Server 2016 (13.x) of de tempdb database.
  • In de knop Toepasselijke regels weergeven worden de evaluatieregels weergegeven die worden gebruikt om de evaluatie van uw servers en databases uit te voeren nadat u Evaluatie aanroepen hebt geselecteerd. Als u informatie over SQL Server en SQL Assessment-API wilt weergeven, selecteert u Info. Resultaten van de evaluatiesessie kunnen worden bekeken op het tabblad Geschiedenis.

SQL Assessment-API met PowerShell

Een tweede optie is het gebruik van PowerShell om het SQL Assessment API-script uit te voeren.

Vereiste voorwaarden

  1. Zorg ervoor dat u PowerShell installeert in Linux.

  2. Installeer de SqlServer PowerShell-module vanuit de PowerShell Gallery, terwijl u bent aangemeld als gebruiker mssql.

    su mssql -c "/usr/bin/pwsh -Command Install-Module SqlServer"
    

De assessment configureren

De uitvoer van de SQL Assessment-API is beschikbaar in JSON-indeling. U moet de volgende stappen uitvoeren om de SQL Assessment-API als volgt te configureren:

  1. Maak in het exemplaar dat u wilt evalueren een aanmelding voor SQL Server-evaluaties met behulp van SQL-verificatie. U kunt het volgende Transact-SQL (T-SQL)-script gebruiken om een aanmeldings- en sterk wachtwoord te maken. Uw wachtwoord moet voldoen aan het standaard SQL Server-wachtwoordbeleid . Standaard moet het wachtwoord ten minste acht tekens lang zijn en tekens bevatten uit drie van de volgende vier sets: hoofdletters, kleine letters, basis-10 cijfers en symbolen. Wachtwoorden mogen maximaal 128 tekens lang zijn. Gebruik wachtwoorden die zo lang en complex mogelijk zijn.

    USE [master];
    GO
    
    CREATE LOGIN [assessmentLogin]
        WITH PASSWORD = N'<password>';
    
    ALTER SERVER ROLE [CONTROL SERVER] ADD MEMBER [assessmentLogin];
    GO
    

    De CONTROL SERVER rol werkt voor de meeste evaluaties. Er zijn echter enkele evaluaties die mogelijk sysadmin-bevoegdheden nodig hebben. Wanneer u die regels niet uitvoert, raden wij aan om CONTROL SERVER machtigingen te gebruiken.

  2. Sla de referenties voor aanmelding op het systeem op, waarbij u <password> vervangt door het wachtwoord dat u in de vorige stap hebt gebruikt.

    echo "assessmentLogin" > /var/opt/mssql/secrets/assessment
    echo "<password>" >> /var/opt/mssql/secrets/assessment
    
  3. Beveilig de nieuwe evaluatiereferenties door ervoor te zorgen dat alleen de mssql gebruiker toegang heeft tot de referenties.

    chmod 600 /var/opt/mssql/secrets/assessment
    chown mssql:mssql /var/opt/mssql/secrets/assessment
    

Het evaluatiescript downloaden

Hieronder volgt een voorbeeldscript dat de SQL Assessment-API aanroept met behulp van de referenties die in de voorgaande stappen zijn gemaakt. Het script genereert een uitvoerbestand in JSON-indeling op deze locatie: /var/opt/mssql/log/assessments.

Opmerking

De SQL Assessment-API kan ook uitvoer genereren in CSV- en XML-indelingen.

Dit script is beschikbaar om te downloaden via GitHub.

U kunt dit bestand opslaan als /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
    }
}

Opmerking

Wanneer u dit script uitvoert in vertrouwde omgevingen en u een prelogin handshake-fout krijgt, voegt u de -TrustServerCertificate vlag toe aan de opdrachten voor $serverNameen $hostNameGet-SqlInstance regels in de code.

De evaluatie uitvoeren

  1. Zorg ervoor dat het script eigendom is van en uitvoerbaar is door mssql.

    chown mssql:mssql /opt/mssql/bin/runassessment.ps1
    chmod 700 /opt/mssql/bin/runassessment.ps1
    
  2. Maak een logboekmap en wijs de juiste machtigingen toe aan de mssql gebruiker in de map:

    mkdir /var/opt/mssql/log/assessments/
    chown mssql:mssql /var/opt/mssql/log/assessments/
    chmod 0700 /var/opt/mssql/log/assessments/
    
  3. U kunt nu uw eerste evaluatie maken, maar ervoor zorgen dat u dit doet als de mssql gebruiker, zodat volgende evaluaties automatisch kunnen worden uitgevoerd via cron of systemd veiliger.

    su mssql -c "pwsh -File /opt/mssql/bin/runassessment.ps1"
    
  4. Zodra de opdracht is voltooid, wordt de uitvoer gegenereerd in JSON-indeling. Deze uitvoer kan worden geïntegreerd met elk hulpprogramma dat ondersteuning biedt voor het parseren van JSON-bestanden. Een van deze voorbeelden is Red Hat Insights.