Usar a API de Avaliação do SQL para SQL Server no Linux

Aplica-se a:SQL Server em Linux

A API de Avaliação SQL fornece um mecanismo para avaliar a configuração do SQL Server para melhores práticas. A API é fornecida com um conjunto de regras contendo práticas recomendadas pela equipe do SQL Server. Este conjunto de regras é melhorado com o lançamento de novas versões. É útil certificar-se de que sua configuração do SQL Server esteja de acordo com as práticas recomendadas recomendadas.

O conjunto de regras enviado pela Microsoft está disponível no GitHub. Você pode visualizar todo o conjunto de regras no repositório de amostras .

Neste artigo, examinamos duas maneiras de executar a API de Avaliação SQL para SQL Server no Linux e contêineres:

extensão de Avaliação SQL para o Azure Data Studio (Pré-visualização)
API de Avaliação SQL com PowerShell

Extensão de Avaliação SQL para o Azure Data Studio (pré-visualização)

A extensão SQL Assessment para o Azure Data Studio (versão prévia) fornece um mecanismo para avaliar a configuração do SQL Server para melhores práticas.

Com esta versão de pré-visualização, pode:

Avaliar um SQL Server, banco de dados SQL do Azure ou Instância Gerenciada SQL do Azure e seus bancos de dados, com regras internas
Obtenha uma lista de todas as regras internas aplicáveis a uma instância e seus bancos de dados
Exportar resultados da avaliação e a lista de regras aplicáveis como um script para armazená-lo em uma tabela SQL
Criar relatórios HTML sobre os resultados das avaliações

Iniciar uma avaliação SQL

Depois de instalar a extensão Avaliação SQL, expanda a lista de servidores, clique com o botão direito do mouse em um servidor ou banco de dados que deseja avaliar e selecione Gerenciar.
Em seguida, na seção Geral, selecione Avaliação SQL . Na guia Avaliação, selecione Invocar Avaliação para executar a avaliação do SQL Server ou do banco de dados Azure SQL selecionado. Quando os resultados estiverem disponíveis, você poderá usar os recursos de filtragem e classificação.
Selecione Exportar como Script para obter os resultados no formato de inserção em tabela. Você também pode selecionar Criar relatório HTML para salvar os resultados da avaliação como um arquivo HTML. Algumas regras de avaliação destinam-se a configurações específicas do SQL Server e outras a outras. O mesmo vale para as regras de banco de dados. Por exemplo, há regras que são aplicáveis somente ao SQL Server 2016 (13.x) ou ao banco de dados tempdb.
O botão Exibir regras aplicáveis exibe as regras de avaliação usadas para executar a avaliação de seus servidores e bancos de dados depois que você seleciona Invocarde Avaliação . Para exibir informações sobre o SQL Server e a API de Avaliação do SQL, selecione Info. Os resultados da sessão de avaliação podem ser revistos no separador Histórico.

API de avaliação SQL com PowerShell

Uma segunda opção é usar o PowerShell para executar o script da API de Avaliação SQL.

Pré-requisitos

Certifique-se de que você instalar o PowerShell no Linux.
Instale o módulo do SqlServer PowerShell a partir da Galeria do PowerShell, em execução como o usuário mssql.
```
su mssql -c "/usr/bin/pwsh -Command Install-Module SqlServer"
```

Configurar a avaliação

A saída da API de Avaliação SQL está disponível no formato JSON. Você deve executar as seguintes etapas para configurar a API de Avaliação SQL da seguinte maneira:

Na instância que você deseja avaliar, crie um logon para avaliações do SQL Server usando a Autenticação SQL. Você pode usar o seguinte script Transact-SQL (T-SQL) para criar um login e uma senha forte. A sua palavra-passe deve seguir a política de palavra-passe padrão do SQL Server. Por padrão, a senha deve ter pelo menos oito caracteres e conter caracteres de três dos quatro conjuntos a seguir: letras maiúsculas, letras minúsculas, dígitos de base 10 e símbolos. As palavras-passe podem ter até 128 caracteres. Use senhas tão longas e complexas quanto possível.
```
USE [master];
GO

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

ALTER SERVER ROLE [CONTROL SERVER] ADD MEMBER [assessmentLogin];
GO
```
A função CONTROL SERVER funciona para a maioria das avaliações. No entanto, há algumas avaliações que podem precisar privilégios de sysadmin. Se não estiver a executar essas regras, recomendamos usar permissões do CONTROL SERVER.
Armazene as credenciais de login no sistema da seguinte forma, substituindo novamente <password> pela senha que você usou na etapa anterior.
```
echo "assessmentLogin" > /var/opt/mssql/secrets/assessment
echo "<password>" >> /var/opt/mssql/secrets/assessment
```
Proteja as novas credenciais de avaliação, garantindo que apenas o usuário mssql possa acessar as credenciais.
```
chmod 600 /var/opt/mssql/secrets/assessment
chown mssql:mssql /var/opt/mssql/secrets/assessment
```

Faça o download do script de avaliação

A seguir está um script de exemplo que chama a API de Avaliação SQL, usando as credenciais criadas nas etapas anteriores. O script gera um arquivo de saída no formato JSON neste local: /var/opt/mssql/log/assessments.

Observação

A API de Avaliação SQL também pode gerar saída nos formatos CSV e XML.

Este script está disponível para download em GitHub.

Você pode salvar este arquivo como /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
    }
}

Observação

Quando você executa esse script em ambientes confiáveis e recebe um erro de handshake de pré-login, adicione o sinalizador -TrustServerCertificate nos comandos para $serverName, $hostName e Get-SqlInstance linhas no código.

Executar a avaliação

Certifique-se de que o script pertence a mssqle pode ser executado por mssql.

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

Crie uma pasta de log e atribua as permissões apropriadas ao usuário mssql na pasta:

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

Agora você pode criar sua primeira avaliação, mas certifique-se de fazê-lo como o usuário mssql, para que as avaliações subsequentes possam ser executadas automaticamente via cron ou systemd com mais segurança.
```
su mssql -c "pwsh -File /opt/mssql/bin/runassessment.ps1"
```
Quando o comando for concluído, a saída será gerada no formato JSON. Essa saída pode ser integrada com qualquer ferramenta que suporte a análise de arquivos JSON. Um desses exemplos de ferramenta é Red Hat Insights.

Feedback

Esta página foi útil?

Last updated on 2025-03-05