SQL Server in a domain environment
Edition selection, the gMSA service account, connections to named instances (SQL Browser, SPN, Kerberos, certificate), logins and roles, transaction log truncation, and backups without SQL Server Agent in an Active Directory domain.
SQL Server in an Active Directory domain depends on several elements that have to be consistent: the edition and its limits, the service account, the name, port and SPN of the instance, logins tied to directory groups, and the recovery model and backups. A mistake in one of them shows up elsewhere: a silent fallback to NTLM, a database without a login after a restore, a log filling the disk. This document describes these elements using one shared example: the domain corp.example.com, servers srv-sql-01 and srv-sql-02, instances CRM, ERP and HR, gMSA accounts CORP\svc-sql$ and CORP\svc-sqlbackup$, and groups GG-SQL-Hosts and GG-SQL-Admins.
Choosing an edition: SQL Server Express limits
Figures refer to SQL Server 2025 (17.x) unless stated otherwise. Express has three scale limits: compute capped at the lesser of 1 socket or 4 cores, a buffer pool of 1410 MB per instance, and a maximum database size of 50 GB (10 GB in versions 2019 and 2022). The processor and memory limits apply per instance, the size limit per database; the number of databases in an instance does not depend on the edition.
The size limit counts the total allocated size of a database’s data files, including free space inside the files; the log file is not counted, and a second data file gains nothing. When a file would have to grow beyond the limit, SQL Server refuses: ALTER DATABASE fails with error 1827, and a query that needs new space gets error 1105. Reads continue, but writes that need new pages stop. Other options exist before changing the edition. Data compression (ROW and PAGE), partitioning and columnstore are available in Express too, but changing a vendor’s database schema needs the vendor’s consent. Space freed inside a file is available for new data immediately, but the allocated size does not change, so the share of the limit drops only after DBCC SHRINKFILE, which fragments indexes and is a one-off operation. For a database approaching 10 GB in version 2019 or 2022, the cheapest answer is often an upgrade to Express 2025, provided the application vendor supports that version; the processor and memory limits do not change.
The 1410 MB limit applies to the buffer pool, the cache of data and index pages, not to the whole process: sqlservr.exe uses more because it needs memory for thread stacks, connections and libraries, so usage above 1.4 GB in Task Manager is not a misconfiguration. In the other direction the limit is absolute: max server memory above this value changes nothing, and adding memory to the server does not help. Whether the limit matters depends on how much of the database is read day to day: a 20 GB database in which work concerns mainly the data of the last few months can run well in 1.4 GB. The signs of a problem are a buffer pool constantly filled to the limit, a low Page life expectancy during working hours (for example a few dozen seconds) and a large number of disk reads. The processor and memory limits apply to a single instance, so several instances on a server can use capacity that one instance cannot; this does not help with the database size limit.
Missing features often matter more than scale limits. Express has no SQL Server Agent, maintenance plans, built-in log shipping, backup compression or encryption, TDE, FCI, availability groups (restoring a backup is then the only recovery path), Database Mail (alerts must come from the monitoring system) or Resource Governor. Without the Agent, backups, index maintenance and DBCC CHECKDB are started by Task Scheduler with sqlcmd.
| Edition | Licence | Processor per instance | Buffer pool | Database size |
|---|---|---|---|---|
| Express | free | lesser of: 1 socket, 4 cores | 1410 MB | 50 GB |
| Standard | paid, production | lesser of: 4 sockets, 32 cores | 256 GB | 524 PB |
| Enterprise | paid, production | operating system maximum | operating system maximum | 524 PB |
The Developer and Evaluation editions have the features of the paid editions, but their licence covers only development, testing and evaluation, so they are not suitable for production servers.
A move to Standard is justified by at least one of these signs: data files exceed about 80% of the limit, will reach it within a few months and archiving is not an option; the buffer pool sits constantly at 1410 MB, Page life expectancy during working hours is low and the disk mostly serves reads from the database; the vendor, the target recovery time and point objectives (RTO, RPO), a security policy or an audit require a feature that Express lacks. A result below 70% of the size limit needs no action, above 80% it is time for a decision: archiving, a version upgrade or an edition change. Changing Express to Standard in the same version happens in place, without moving databases: SQL Server Installation Center, Maintenance, Edition Upgrade, with the Standard product key (in silent mode setup.exe /q /ACTION=EditionUpgrade /INSTANCENAME=CRM with the /PID and /IACCEPTSQLSERVERLICENSETERMS parameters). The instance restarts its services, so a short outage is required, and the Agent service (disabled after an Express installation) has to be set to automatic start and its account configured. Enterprise is justified when an instance needs more than 32 cores or 256 GB of buffer pool, availability groups with several databases and more than two replicas, or online operations such as index rebuilds without blocking the table.
Service account: gMSA
The password of a service account set to “Password never expires” usually stays unchanged for years, and it is known to several people, including some who no longer work in the organisation. Changing it requires a new password in Active Directory, typing it by hand into every SQL service on every server and a restart of every instance; a service missed during the change fails to start after the next server restart and reports error 1069 (“The service did not start due to a logon failure”). The group Managed Service Account (gMSA) removes this problem at the source.
Mechanism
A gMSA is an Active Directory object similar in structure to a computer account. The domain controller calculates the password from the KDS (Key Distribution Service) root key and the account attributes, and rotates it every 30 days by default. The interval can be set only when the account is created (-ManagedPasswordIntervalInDays); a different interval requires a new account. Only principals listed in the msDS-GroupMSAMembership attribute (the -PrincipalsAllowedToRetrieveManagedPassword parameter) can retrieve the password, most simply a group of computers, here GG-SQL-Hosts with servers srv-sql-01 and srv-sql-02. A server in the group retrieves the current and the previous password, so a password change does not require restarting services. SQL Server supports gMSA as a service account from version 2014.
| Feature | Virtual account | Ordinary domain account | gMSA |
|---|---|---|---|
| Who knows the password | nobody, the account has no password | the administrator who set it and anyone it was passed to | nobody, the domain controller calculates it |
| Password change | not applicable | manually in AD and in every service, with a restart | automatic, every 30 days by default, without a restart |
| Access to network resources | as the computer account, e.g. CORP\srv-sql-01$ | as that account | as CORP\svc-sql$ |
| Use on several servers | no | yes | yes, on servers in the GG-SQL-Hosts group |
By default the installer runs the engine under a virtual account, for example NT SERVICE\MSSQL$CRM. This is a correct setting for a single server without network resources. On the network a virtual account appears as the computer account, so a permission on a backup share goes to the whole server with all its services, and SPNs for custom instance names have to be registered on the computer account and moved together with the instance.
Creating the account
Domain controllers need a KDS root key before they can calculate gMSA passwords. The key is created once per forest, on a domain controller, with Domain Admins or Enterprise Admins rights, after checking with Get-KdsRootKey that it does not already exist. Despite the name of the -EffectiveImmediately switch, domain controllers wait up to 10 hours after the key is created so that replication can distribute it before they allow the account to be created; the effective date is shown by the EffectiveTime field. In a laboratory with a single domain controller the documentation allows a date 10 hours in the past (-EffectiveTime), in production it does not. Add-KdsRootKey called without parameters sets the effective date to 10 days after creation, not to now. The key is not deleted and recreated as an experiment: domain controllers cache the old key, and after it is recreated the KDC service has to be restarted on each of them.
The account is created by New-ADServiceAccount, by default in the Managed Service Accounts container. The -DNSHostName parameter is required for a group account, and -KerberosEncryptionType restricts ticket encryption to the listed types, here AES128 and AES256. An additional SQL server is added to the GG-SQL-Hosts group, not to the account itself: Set-ADServiceAccount with -PrincipalsAllowedToRetrieveManagedPassword sets the list of permitted principals from scratch and can easily remove access from working servers.
# Only when Get-KdsRootKey returns nothing: KDS root key, once per forest
Add-KdsRootKey -EffectiveImmediately
# Group of computers that can retrieve the account password
New-ADGroup -Name GG-SQL-Hosts -GroupScope Global -GroupCategory Security
Add-ADGroupMember -Identity GG-SQL-Hosts -Members 'srv-sql-01$', 'srv-sql-02$'
# gMSA account; the password change interval can be set only now
New-ADServiceAccount -Name svc-sql -DNSHostName svc-sql.corp.example.com `
-PrincipalsAllowedToRetrieveManagedPassword GG-SQL-Hosts `
-ManagedPasswordIntervalInDays 30 `
-KerberosEncryptionType AES128, AES256
Each SQL server needs the ActiveDirectory module for PowerShell (Install-WindowsFeature RSAT-AD-PowerShell). Install-ADServiceAccount -Identity svc-sql installs the account on the server and caches it locally, and Test-ADServiceAccount -Identity svc-sql checks whether the server can retrieve the password; both require an administrator session. A False result usually has one of three causes: the server is not in the GG-SQL-Hosts group or does not know it yet, the KDS key has not reached the domain controller the server is talking to, or the server does not support the encryption types required by the account. The group list enters the Kerberos ticket of the computer account when the ticket is issued, so a server added to the group after it started still holds a ticket with the old list and cannot retrieve the password until the ticket is renewed, usually within 10 hours. A server restart helps, as does klist purge -li 0x3e7 in an administrator command prompt, which removes the SYSTEM session tickets.
Changing the service account
The instance account is changed in SQL Server Configuration Manager: SQL Server Services, properties of the SQL Server (CRM) service, Log On tab, This account option. The account is entered with the trailing dollar sign (CORP\svc-sql$), and the password fields stay empty. The new account takes effect after the service restarts, and the databases of the instance are unavailable for that time; this is the only outage in the deployment, so the change is planned for a maintenance window, and later password changes happen without restarts. The Services snap-in (services.msc) is not the right tool: Microsoft recommends changing SQL Server service accounts only with its own tools, and Configuration Manager also updates the local security store that protects the service master key. According to the documentation, file and registry permissions of the instance and the Log on as a service right belong to the service identifier NT SERVICE\MSSQL$CRM, so in most components an account change does not require granting permissions again.
Before switching to the new account, everything granted to the old one is moved over: permissions on network shares (for example the one holding backups), logins of the old account on other instances and delegation settings. The SPNs are removed from the old account and registered on CORP\svc-sql$.
One account for all instances or several
A shared svc-sql account for the CRM, ERP and HR instances on both servers is the simplest: the SPNs of all instances sit on one account, delegation is configured once, and moving an instance from srv-sql-01 to srv-sql-02 comes down to changing a DNS record. The price is the scope of a compromise. Any process running as SYSTEM on any server in the GG-SQL-Hosts group can retrieve the account password, because that is how the system itself retrieves it. An attacker who takes over one instance, for example through xp_cmdshell, acts on the network as CORP\svc-sql$, with access to the shares of all instances, their delegation and the logins granted to this account on other servers.
The practical rule is one account per group of instances with similar data sensitivity and the same administrators; the instance with personnel data (HR) gets a separate gMSA account. A separate account only partly limits the effects of compromising another instance on the same server, because SQL Server service accounts hold the SeImpersonatePrivilege privilege, which often allows escalation to system level; full isolation is provided only by a separate server.
Connecting to a named instance
A connection to a named instance depends on elements that the client determines on its own: the port, the SQL Browser service, the DNS name, the SPN on the service account and the server certificate. Each of them fails separately: a missing Browser gives error 26, a missing SPN silently switches authentication to NTLM, and an untrusted certificate breaks the connection after a driver update. The common solution is a fixed port, a separate DNS name for each instance, a manually registered SPN and a certificate from an internal certification authority.
Instances and SQL Browser
One server can run one default instance and many named instances. Each is a separate Windows service with its own sqlservr.exe process, network configuration and port. The default instance (MSSQLSERVER) has no name in the address and listens on TCP 1433. A named instance (service MSSQL$CRM, address srv-sql-01\CRM) by default gets a dynamic port chosen when the service starts, because two instances cannot use the same port. Express installs as the named instance SQLEXPRESS and follows the same rules.
At startup the SQL Server Browser service takes UDP port 1434 and records the TCP ports and named pipes of all instances on the server. A client with the address srv-sql-01\CRM sends a query containing the instance name to UDP 1434 (the format is described in MC-SQLR) and only after the reply opens a TCP connection to the right port. The following rules result:
- without a running Browser, a connection in the form
server\INSTANCEwith no port fails with error 26 (Error Locating Server/Instance Specified), while connections with a port specified keep working; - the default instance does not need the Browser as long as it listens on port 1433; with another port the client has to specify it;
- the installer sets the Browser to start automatically when a named instance is installed, Express included; changing it to manual or disabled produces the symptom only at the next server restart, so the cause can be distant in time from the effect;
- the Browser accepts queries without authentication, so the firewall rule for UDP 1434 admits only the application subnets, here
10.10.30.0/24; - on a server with several IP addresses the Browser reply can leave from a different address than the one the client sent the query to; the Windows firewall on the client side drops such a datagram and the connection through
server\INSTANCEtimes out although the Browser is running, and the solution is a port in the connection string.
Fixed port instead of dynamic
A dynamic port can change after an instance restart if another process takes it. Clients find it through the Browser, so the connection keeps working, but firewall rules for a specific port, manually registered SPNs and connection strings with a port stop matching. The fixed port is set in SQL Server Configuration Manager: Protocols for CRM, TCP/IP, IP Addresses tab, IPAll section. The TCP Dynamic Ports field must be empty, and TCP Port contains the port number; the change takes effect after the service restarts. The value 0 in TCP Dynamic Ports does not disable the dynamic port, it enables it. The port number is chosen outside the range 49152–65535, which Windows uses for ephemeral ports. Clients connecting through name,port then do not need the Browser, which remains a convenience for administrators typing srv-sql-01\CRM into SSMS.
A separate DNS name for each instance
A separate DNS name for each instance is more convenient than exposing an instance under the server name. The application then does not know the server name, and moving the instance comes down to changing a DNS record; with the same gMSA account the SPN stays unchanged.
| Instance | DNS name (A record) | TCP port | SPN |
|---|---|---|---|
| CRM | sql-crm.corp.example.com | 14331 | MSSQLSvc/sql-crm.corp.example.com:14331 |
| ERP | sql-erp.corp.example.com | 14332 | MSSQLSvc/sql-erp.corp.example.com:14332 |
| HR | sql-hr.corp.example.com | 14333 | MSSQLSvc/sql-hr.corp.example.com:14333 |
An alias in the form of a CNAME record looks equivalent, but the client driver usually builds the SPN from the canonical name, that is, the target name of the record. A client connecting to the alias requests a ticket for MSSQLSvc/srv-sql-01.corp.example.com:14331, and the SPN registered for the alias is not used. The instance name has to be an A record.
Address in the connection string
The server address has the form [protocol:]server[\instance][,port], and the prefix forces the protocol:
| Address | Meaning |
|---|---|
srv-sql-01\CRM | port from SQL Browser (UDP 1434) |
tcp:sql-crm.corp.example.com,14331 | TCP only, port given explicitly |
np:\\srv-sql-01\pipe\MSSQL$CRM\sql\query | named pipe over SMB (TCP 445) |
lpc:srv-sql-01\CRM | shared memory, local only |
When a port is given, the Browser is not queried. Applications use the full DNS name rather than an IP address: with an IP address the driver tries to resolve it to a full name and builds the SPN from it, and NTLM appears when resolution fails or no SPN exists for that name. The driver also usually does not match an IP address to a name in the certificate unless it is in the SAN extension. Without a prefix the driver tries the enabled protocols in turn, so after a TCP failure the message may concern the last attempt (e.g. Named Pipes Provider, error: 40); the tcp: prefix removes this ambiguity. Named pipes are disabled for network connections after installation in all editions.
In a new installation of the Express and Developer editions the TCP/IP protocol is disabled, unlike Enterprise and Standard: local connections work, and nobody connects from other computers. TCP/IP is enabled in SQL Server Configuration Manager (SQL Server Network Configuration, Protocols for HR, TCP/IP, Enable), and the instance service is restarted.
Encryption required by default and the certificate
New versions of Microsoft drivers and tools require encryption by default and validate the server certificate (as of October 2026):
| Driver or tool | From version | Default setting |
|---|---|---|
| Microsoft.Data.SqlClient | 4.0 | Encrypt=True, from 5.0 Mandatory |
| ODBC Driver for SQL Server | 18 | Encrypt=yes (Mandatory) |
| OLE DB Driver for SQL Server (MSOLEDBSQL19) | 19 | Encrypt=Mandatory |
| SQL Server Management Studio | 20 | Encryption: Mandatory |
An instance without a configured certificate generates a self-signed certificate at startup, which clients do not trust by default, so after a driver update an application that worked for years reports The certificate chain was issued by an authority that is not trusted. The quickest workaround is TrustServerCertificate=True: the connection stays encrypted, but the client does not verify the server’s identity, so someone who intercepts the traffic can substitute their own server. With Encrypt=Strict (TDS 8.0, from SQL Server 2022) this setting does not work. Encrypt=False is a worse option: when the server does not enforce encryption, only the login is encrypted and the data travels in clear text.
The proper solution is a certificate from an internal certification authority (AD CS) that domain computers trust. It is issued with the Server Authentication enhanced key usage and with all names used by clients in the SAN extension (sql-crm.corp.example.com, sql-erp.corp.example.com, sql-hr.corp.example.com and srv-sql-01.corp.example.com). The private key must be held by a legacy CSP provider (KeySpec equal to AT_KEYEXCHANGE), not by a KSP, and the service account CORP\svc-sql$ needs read permission on that key in LocalMachine\My. The certificate is specified separately for each instance in Configuration Manager (Properties, Certificate tab), and the change takes effect after the service restarts. The expiry date is covered by certificate monitoring, because some clients reject an expired certificate on every connection. When an application has to connect using a name that is not in the certificate, Microsoft.Data.SqlClient from version 5.0 accepts the HostNameInCertificate parameter: it changes only the name comparison and does not disable chain or validity checks, so it is safer than TrustServerCertificate.
Kerberos authentication and delegation
For Windows authentication the client driver asks the domain controller for a ticket for a service with a specific name, the SPN (Service Principal Name). The controller looks for the account with that SPN in the servicePrincipalName attribute and encrypts the ticket with that account’s key, and SQL Server decrypts it with the key of the account the service runs under. For SQL Server the SPN has one of three forms: MSSQLSvc/sql-crm.corp.example.com:14331 for TCP connections (name and port), MSSQLSvc/srv-sql-01.corp.example.com:CRM for a named instance connecting over named pipes, or MSSQLSvc/srv-sql-01.corp.example.com for the default instance with a protocol other than TCP.
Text description of the diagram
The client connects with the string Server=sql-crm,14331. In step 1 it resolves the name in DNS: an A record points to 10.10.20.11 and fixes the canonical name.
In step 2 it builds the SPN from the canonical name and the port, in the form MSSQLSvc/sql-crm…:14331, and asks the domain controller (KDC) for a ticket. The domain controller must find that SPN on the svc-sql$ service account.
In step 3 SQL Server decrypts the ticket and authenticates the client with Kerberos. When the SPN does not exist on the service account, the connection silently falls back to NTLM, with no delegation.
The driver usually resolves the name from the connection string in DNS and uses the canonical name, and takes the port from the connection string or from SQL Browser; details depend on the client stack. If the domain controller does not find an SPN with a name built this way, the Negotiate mechanism selects NTLM without any message. The connection works, but without mutual authentication of the server and without delegation.
| Symptom | Typical cause |
|---|---|
auth_scheme equal to NTLM on a connection from another machine | no SPN for the name and port the client uses |
Cannot generate SSPI context | SPN registered on an account other than the service account, or the same SPN on two accounts |
| NTLM only when connecting through an alias | the alias is a CNAME record or has no SPN for the alias name |
| NTLM when connecting by IP address | the address was not resolved to a full name or no SPN exists for that name |
| NTLM after an instance restart | dynamic port different from the port in the registered SPN |
ANONYMOUS LOGON on a linked server | first connection over NTLM or delegation not configured |
SPN registration
The SPN must be registered on the account the service runs under; a gMSA works best, because the domain controller rotates the password and one account serves instances on several servers. At startup the SQL Server service tries to register its SPNs on the service account, and removes them at shutdown. This succeeds only when the account has read and write permission on the servicePrincipalName attribute of its own object. According to the documentation, SPNs can be registered by built-in accounts (e.g. NETWORK SERVICE), virtual accounts, managed service accounts (MSA) and accounts with the permission to register SPNs; for other accounts a domain administrator registers them manually. For MSA it is stated that registration requires read and write permissions on servicePrincipalName to be granted. The documentation does not settle the gMSA case separately, so before relying on automatic registration the error log is checked after the instance starts; missing permissions show as the message could not register the Service Principal Name with code 0x2098.
Automatic registration covers only the server name, and full write permission lets the account add any SPN to itself, including one that belongs to another service. For named instances with their own DNS names manual registration works better, and an entry with code 0x2098 in the log at every start is then expected; the risk is a missing or outdated SPN after a change of port, name or service account. setspn requires domain administrator rights or a delegated write permission on servicePrincipalName. The -S switch refuses to register an SPN that already exists on another account, and setspn -X searches the domain for duplicates (the correct result is found 0 group of duplicate SPNs). When an instance moves to a server with a different service account, the SPN is first removed from the old account (setspn -D) and only then added to the new one.
Delegation for linked servers
Kerberos is a necessary but not sufficient condition. When the CRM instance runs a query on behalf of a user through a linked server to the ERP instance, the CRM service account must have the right to pass on the user’s identity; with NTLM this ends with the error Login failed for user 'NT AUTHORITY\ANONYMOUS LOGON', because NTLM does not allow identity to be passed further. Linked servers support unconstrained delegation and, from SQL Server 2017 CU17, constrained delegation; resource-based constrained delegation is not supported for them. The safe variant is constrained delegation with Kerberos only: msDS-AllowedToDelegateTo of the service account contains only the SPN of the ERP instance, without the TrustedToAuthForDelegation flag. Unconstrained delegation (Trust this user for delegation to any service) is not enabled: the service account could act on behalf of any user towards any service in the domain. The linked server login uses the current security context of the user (@useself = 'TRUE' in sp_addlinkedsrvlogin), and the user also has access on the ERP instance.
setspn -S MSSQLSvc/sql-crm.corp.example.com:14331 'CORP\svc-sql$'
# Only when clients connect over named pipes
setspn -S MSSQLSvc/srv-sql-01.corp.example.com:CRM 'CORP\svc-sql$'
# The service account can pass on the user's identity only to the service with this SPN
Set-ADServiceAccount -Identity svc-sql -Add @{'msDS-AllowedToDelegateTo' = 'MSSQLSvc/sql-erp.corp.example.com:14332'}
The authentication scheme of existing connections is shown by the auth_scheme column in sys.dm_exec_connections (joined to sys.dm_exec_sessions on session_id, filtered with net_transport = 'TCP' and auth_scheme <> 'SQL'). Connections from other machines are assessed, because a connection from the server itself shows NTLM even when the SPN is correct. Every row with NTLM is a client connecting by a name or port without an SPN, through a CNAME alias or by IP address.
Logins, users and roles
A login is an instance-level object. It is stored in the master database, visible in sys.server_principals, and decides whether SQL Server accepts the connection. A Windows login corresponds to an account or group from the directory and has no password in SQL Server, while a SQL login has a name and a password hash stored in master. A user is a database-level object (sys.database_principals); permissions and roles are granted to it. It is stored in the database itself, so it goes into the backup and returns on restore. It is tied to the login by the SID stored in both places, not by the name. A Windows login has the SID of the Active Directory account, the same on every server in the domain, while a SQL login gets its SID at CREATE LOGIN, so the same login created on two servers has two different identifiers.
Directory groups instead of personal accounts
Logins for individuals form a list that nobody can verify. A better layout is logins only for groups, for example GG-SQL-CRM-Read for people reading CRM data and GG-SQL-CRM-Write for those who change it. For each group there is a login at instance level (CREATE LOGIN [CORP\GG-SQL-CRM-Read] FROM WINDOWS) and a user in the database tied to it by SID (CREATE USER … FOR LOGIN …). Granting access means adding a person to a group in Active Directory, and disabling the account also closes access to SQL Server.
A group login cannot be disabled with ALTER LOGIN … DISABLE, which fails with error Msg 15151. A group is blocked with the permission DENY CONNECT SQL TO [CORP\GG-SQL-CRM-Read]. A denial takes precedence over grants obtained another way, so it also covers group members who have access through another group or their own login; it does not apply to members of the sysadmin role. SQL Server reads group membership from the Windows token at sign-in and keeps it for the whole duration of the connection: a person added to a group gets access only after signing in to Windows again and opening a new connection, and removal from a group does not end open sessions, for which KILL is used.
Server and database roles
The sysadmin role can do everything, and DENY does not apply to its members. The installer adds to it the sa account, the instance service identifiers (NT SERVICE\MSSQL$CRM, NT SERVICE\SQLAgent$CRM), NT SERVICE\SQLWriter and NT SERVICE\Winmgmt, and the accounts specified during installation. Apart from service entries the role should contain one group: GG-SQL-Admins. The securityadmin role manages logins and grants permissions, but the documentation says to treat it as equivalent to sysadmin, because the ability to grant permissions allows most server permissions to be assigned; CONTROL SERVER is treated the same way. From SQL Server 2022 (16.x) there are fixed roles with a narrow scope: ##MS_LoginManager## creates and alters logins but does not grant permissions, and ##MS_ServerStateReader## gives a monitoring account read access to DMVs.
Fixed database roles act on the whole database: db_datareader and db_datawriter cover all tables but do not allow procedures to be executed, and according to the documentation members of db_ddladmin can escalate their own permissions. A more precise model is custom roles with schema-level permissions. Application objects live in the app schema, and a role receives rights on the whole schema (GRANT SELECT ON SCHEMA::app TO crm_read; GRANT SELECT, INSERT, UPDATE, DELETE, EXECUTE ON SCHEMA::app TO crm_write), so new tables and procedures are covered without further grants. Thanks to ownership chaining, a role member with only EXECUTE runs a procedure that changes tables to which there are no direct rights. Members of the custom roles are the users of directory groups (ALTER ROLE crm_read ADD MEMBER …). Custom roles are not added as members of fixed roles, because the documentation identifies this as a route to unintended privilege escalation.
| Role | Who gets it |
|---|---|
sysadmin (server) | the GG-SQL-Admins group and service accounts added by the installer |
securityadmin (server) | nobody outside sysadmin; from SQL Server 2022 ##MS_LoginManager## instead |
##MS_ServerStateReader## (server, from 2022) | the monitoring account |
db_owner, db_ddladmin (database) | database administrators and the account deploying schema changes, not the application account |
db_datareader, db_datawriter (database) | reports reading the whole database; writing is usually better based on a custom role |
custom role with GRANT … ON SCHEMA | the application and user groups |
db_backupoperator (database) | the backup task account, without table read permission |
Application account, mixed mode and SQL login passwords
An application with a SQL login keeps its password in a configuration file, often in clear text, and changing it requires a simultaneous change on all application servers. A better layout is an application running under a Windows account: an IIS application pool or a Windows service under a gMSA account, for example CORP\svc-crm-app$. The account gets a login and a user like the groups, and membership in the crm_write role rather than db_owner. When everyone signs in with Windows accounts, mixed mode (which accepts SQL logins) is not needed. The sa account belongs to the sysadmin role and stays disabled (ALTER LOGIN sa DISABLE), also after switching to mixed mode.
When a SQL login is unavoidable, two options govern the password. CHECK_POLICY (default ON) applies the Windows password policy: length, complexity and lockout after failed attempts. CHECK_EXPIRATION (default OFF) adds password expiry; the combination CHECK_POLICY = OFF with CHECK_EXPIRATION = ON is not supported. For an application login a reasonable set is CHECK_POLICY = ON and CHECK_EXPIRATION = OFF with a planned password change, because expiry means an outage on the day of expiration. With CHECK_POLICY = ON the login is locked after the failed-sign-in threshold is exceeded, so one server with an old password after a change quickly locks the login for all the others. The state is shown by LOGINPROPERTY(name, 'IsLocked'), and unlocking happens through ALTER LOGIN crm_app WITH PASSWORD = '…' UNLOCK or by disabling and re-enabling CHECK_POLICY.
User without a login after restoring a database
The CrmDB database restored from a backup on srv-sql-02 contains the user crm_app with the SID of the login from srv-sql-01, while the login created on srv-sql-02 has a new SID. This is an orphaned user: the application cannot connect, and an attempt to map the login to the database in SSMS fails with error 15023. ALTER USER crm_app WITH LOGIN = crm_app rewrites the user’s SID in the database to the SID of the specified login from this instance, and roles and permissions stay unchanged. When a backup goes to the second server regularly, the SQL login is created there with the same SID: it is read from sys.sql_logins and given in CREATE LOGIN … WITH SID = ….
The Domain Admins group login has the sysadmin role, but an administrator signed in to the SQL server opens SSMS and gets a sign-in error (18456, usually state 11) or sees no databases. The cause is User Account Control (UAC): a process without elevation receives a filtered token in which privileged groups are used only for denial. A dedicated GG-SQL-Admins group is better than running SSMS as administrator, and Domain Admins accounts do not sign in to member servers.
Transaction log and recovery model
A log file CrmDB_log.ldf of 80 GB against a 5 GB data file, no free disk space and error 9002 (The transaction log for database 'CrmDB' is full due to 'LOG_BACKUP'.), after which the application stops saving changes, is usually not a result of a failure but of the FULL model without log backups: SQL Server keeps every change until it reaches a log backup.
Log truncation
Every change in the database goes first to the transaction log and only later to the data file. The log is usually a single .ldf file, divided internally into virtual log files (VLFs), which are created when the file is created and at every growth. New records are appended at the end of the log. The part from the oldest record still needed to recover the database after a failure (MinLSN) to the last written record is the active part of the log; its beginning is determined, among other things, by the oldest open transaction. VLFs lying entirely before MinLSN are inactive, but are eligible for reuse only after log truncation. When writing reaches the end of the file, it wraps to the beginning, to the freed VLFs. If no VLF is free, SQL Server grows the file by the FILEGROWTH value, and when it cannot, it raises error 9002. Truncation does not shrink the file: it is a logical operation that marks inactive VLFs as ready for reuse. The file on disk is shrunk only by DBCC SHRINKFILE, and shrinking the file does not solve the problem while something blocks truncation.
In the SIMPLE model the log is truncated automatically after a checkpoint, and log backups cannot be taken, so with a full backup taken every night losing the database files at 16:00 means losing the changes of the whole day. In the FULL model the log is truncated only after a log backup (BACKUP LOG), provided a checkpoint has occurred since the previous backup; a full database backup does not truncate the log. In return, the chain of log backups allows the database to be restored to a chosen moment, for example to the minute before an accidental DELETE without a WHERE clause.
| Feature | SIMPLE | FULL |
|---|---|---|
| Possible data loss | changes since the last full or differential backup | changes since the last log backup |
| Point-in-time restore | no | yes, RESTORE LOG … WITH STOPAT |
| Log shipping, availability groups | no | yes |
| Default in edition | Express | Standard and Enterprise |
In the Standard and Enterprise editions the model system database uses the FULL model, and every new database inherits it from there. In Express model defaults to SIMPLE, so FULL is set manually. Until the first full backup a FULL database behaves like SIMPLE. Then a nightly full backup appears, nobody schedules log backups, and no VLF is freed any more: the file grows with every working day, every index rebuild and every import, the full backups succeed and the disk fills over several months. There are two solutions: schedule log backups or consciously change the model to SIMPLE.
log_reuse_wait_desc: what the log is waiting for
The log_reuse_wait_desc column in sys.databases shows what blocked log reuse at the last checkpoint; the same value appears in the error 9002 message after the words full due to.
| Value | Cause | What to do |
|---|---|---|
NOTHING | the log has free VLFs | nothing; an oversized file can be shrunk once |
LOG_BACKUP | a FULL or BULK_LOGGED database is waiting for a log backup | log backup and a permanent schedule, or a deliberate switch to SIMPLE |
ACTIVE_BACKUP_OR_RESTORE | a data backup or restore is in progress | wait for the operation to finish |
ACTIVE_TRANSACTION | a long or abandoned transaction, in any model | find it with DBCC OPENTRAN, commit or roll it back |
REPLICATION, AVAILABILITY_REPLICA | replication, CDC or an availability group replica has not yet consumed the log | check the Log Reader agent or the queues on the replicas |
In a database with regular log backups the LOG_BACKUP value is normal; the problem is a missing backup or intervals longer than planned. Switching to SIMPLE helps only with LOG_BACKUP: with ACTIVE_TRANSACTION it frees nothing and merely breaks the log backup chain.
Repair and file size
If the database is to stay in FULL, the first step is a log backup (BACKUP LOG [CrmDB] TO DISK = … WITH CHECKSUM; the .trn file becomes part of the chain). It takes as much space as the used part of the log, so the target disk must hold even several dozen gigabytes. When the log has never been backed up, two log backups are needed so that the database engine can truncate the log to the point of the last backup. If losing the changes since the last full backup is acceptable, the database can be switched to SIMPLE (ALTER DATABASE [CrmDB] SET RECOVERY SIMPLE, then CHECKPOINT). The change breaks the log backup chain: point-in-time restore is no longer possible, and the scheduled log backups of this database have to be disabled.
When log_reuse_wait_desc shows NOTHING, the file can be shrunk. The target size is not zero but as much as the log needs in the busiest period between log backups; for the example database 4 GB is reasonable. The file is shrunk to 1024 MB (DBCC SHRINKFILE (N'CrmDB_log', 1024), only down to a VLF boundary) and then grown to the target size in one step (ALTER DATABASE [CrmDB] MODIFY FILE (NAME = N'CrmDB_log', SIZE = 4096MB)), which gives a reasonable number of VLFs. If DBCC SHRINKFILE does not reach the requested size, the active part of the log is at the end of the file and the command has to be repeated after the next log backup. Shrinking is meant to be a one-off: a nightly job with DBCC SHRINKFILE or AUTO_SHRINK is a vicious circle, because the file grows again under the next load, and Microsoft advises against treating file shrinking as routine maintenance.
A percentage growth increment grows with the file: at 10% an 80 GB file grows by 8 GB at once. From SQL Server 2022 only log growth increments of up to 64 MB benefit from instant file initialisation, so an 8 GB increment is still zeroed and writes wait for the operation to finish; in earlier versions every log increment is zeroed. A fixed increment in megabytes (FILEGROWTH) is reasonable: 64 MB for small logs, 256–512 MB for logs of several gigabytes and no more than 1024 MB.
Backups without SQL Server Agent
The lack of the Agent does not mean the lack of backups: BACKUP and RESTORE work in Express as in the higher editions, except for backup compression and encryption, and the missing timed-execution mechanism is replaced by Task Scheduler, a PowerShell script with sqlcmd and a gMSA account. A .bak file from Express can be restored on any edition of the same or a newer version. Log backups are taken for databases in the FULL and BULK_LOGGED models. Log backups restored in sequence on a second server replace log shipping, which Express lacks.
Task account and permissions
The backup tasks run under a separate gMSA account CORP\svc-sqlbackup$, not under the service account CORP\svc-sql$, so taking over a task does not yield the identity of the database engine. The account is created like a service account, with the GG-SQL-Hosts group as the list of servers permitted to retrieve the password. In SQL Server it gets a login (CREATE LOGIN [CORP\svc-sqlbackup$] FROM WINDOWS) and the db_backupoperator role in every database, that is BACKUP DATABASE, BACKUP LOG and CHECKPOINT without permission to read tables. The user is created in the databases once, in a loop over sys.databases (without tempdb, ONLINE databases only); running it again reports error 15023 for databases where the user already exists, and databases restored from another server have to be completed manually, otherwise the first backup fails with a permissions error. The backup file is written by the SQL Server process, not by the task account, so write permission on the backup directory goes to the service identifier NT SERVICE\MSSQL$CRM, which covers only this instance. The task account gets modify permission on the directory and change permission on the SQLBackup share on the target server.
Backup script
-Type Full takes a full backup of all databases except tempdb, and -Type Log covers FULL and BULK_LOGGED databases with a started backup chain (last_log_backup_lsn in sys.database_recovery_status is not NULL), because BACKUP LOG without a full backup fails with error 4214. A new database therefore gets its first log backup after the next full backup.
#Requires -Version 5.1
param(
[Parameter(Mandatory)][ValidateSet('Full', 'Log')][string]$Type,
[string]$Instance = "$env:COMPUTERNAME,14331",
[string]$Root = 'D:\SQLBackup\CRM',
[string]$Share = '\\srv-sql-02\SQLBackup\CRM',
[int]$RetentionDays = 14
)
$stamp = Get-Date -Format 'yyyyMMdd_HHmmss'
$log = Join-Path $Root ('backup_{0}_{1:yyyyMM}.log' -f $Type, (Get-Date))
$failed = 0
# Log backup: FULL and BULK_LOGGED databases with a started chain; full backup: all except tempdb
$filter = "d.recovery_model_desc IN ('FULL', 'BULK_LOGGED') AND r.last_log_backup_lsn IS NOT NULL"
if ($Type -eq 'Full') { $filter = "d.name <> 'tempdb'" }
$query = "SET NOCOUNT ON; SELECT d.name FROM sys.databases AS d " +
"JOIN sys.database_recovery_status AS r ON r.database_id = d.database_id " +
"WHERE d.state_desc = 'ONLINE' AND $filter;"
$databases = sqlcmd -S $Instance -E -C -b -h -1 -W -w 1024 -Q $query | Where-Object { $_ }
if ($LASTEXITCODE -ne 0) { exit 1 }
foreach ($db in $databases) {
$dir = Join-Path $Root $db
New-Item -ItemType Directory -Path $dir -Force | Out-Null
if ($Type -eq 'Full') {
$sql = "BACKUP DATABASE [$db] TO DISK = N'$dir\${db}_${stamp}_FULL.bak' WITH CHECKSUM, INIT;"
} else {
$sql = "BACKUP LOG [$db] TO DISK = N'$dir\${db}_${stamp}_LOG.trn' WITH CHECKSUM, INIT;"
}
sqlcmd -S $Instance -E -C -b -Q $sql | Out-File -FilePath $log -Append -Encoding utf8
if ($LASTEXITCODE -ne 0) { $failed++ }
}
# Copy to the share: for a log backup only .trn files
$mask = if ($Type -eq 'Full') { '*.bak', '*.trn' } else { '*.trn' }
robocopy $Root $Share $mask /S /R:3 /W:10 /NP /NJH /NJS "/LOG+:$log" | Out-Null
if ($LASTEXITCODE -ge 8) { $failed++ }
# Retention after a successful full backup: files older than N days and older than the last full backup
if ($Type -eq 'Full' -and $failed -eq 0) {
$limit = (Get-Date).AddDays(-$RetentionDays)
foreach ($folder in Get-ChildItem -Path $Root -Directory) {
$files = Get-ChildItem -Path $folder.FullName -File | Where-Object Extension -in '.bak', '.trn' | Sort-Object Name
$lastFull = $files | Where-Object Name -like '*_FULL.bak' | Select-Object -Last 1
if (-not $lastFull) { continue }
$files | Where-Object { $_.Name -lt $lastFull.Name -and $_.LastWriteTime -lt $limit } | Remove-Item
}
}
if ($failed -gt 0) { exit 1 }
exit 0
The script connects to the local instance by port, not by the name sql-crm, so that after the A record is switched the task on the old server does not start backing up the new server to its own disk. The file name (CrmDB_20261018_101500_LOG.trn) makes alphabetical order equal to execution order, which retention and restore rely on. WITH CHECKSUM stores a checksum of the whole backup, which RESTORE later verifies; a page with a bad checksum aborts the backup. The -b switch gives exit code 1 on an error of severity above 10, and -C trusts the server certificate without validation and stays only until a certificate from the internal authority is deployed; after that it is removed. Exit code 1 of the script reaches Task Scheduler and, without Database Mail, is the main signal for monitoring.
A local backup copied immediately afterwards gives a fast restore from disk and a copy that survives a server failure; a backup written directly to the share would make the write depend on its availability. Retention deletes files older than 14 days, but only those from before the last full backup, so that backup and the log backups after it always remain. The script prunes only the local copy in the $Root directory; the copy on the share needs separate retention on the second server. The share on srv-sql-02 and both servers are in the domain, so an account with Domain Admins rights reaches all the backups at once. A third copy of the .bak files goes to a repository outside the domain or to object storage with object lock, with separate credentials.
Task Scheduler under a gMSA account
A gMSA account has no password to type into the wizard, so the task is registered in PowerShell: New-ScheduledTaskPrincipal -UserId 'CORP\svc-sqlbackup$' -LogonType Password, without supplying a password, and then Register-ScheduledTask with the action powershell.exe -NoProfile -NonInteractive -File C:\Scripts\Backup-SqlInstance.ps1 -Type Full. The CRM - FULL task starts daily at 01:00, and the CRM - LOG task (-Type Log) at 00:05, repeating every 15 minutes for 10 years (-RepetitionInterval, -RepetitionDuration). Starting the log task at 00:05 avoids 01:00, when the full backup starts, but log backups can overlap a running full backup, because the documentation allows a log backup at any time after the first full backup. Task Scheduler grants the account the Log on as a batch job right automatically, unless that right is set by a domain GPO; the gMSA account then has to be added in that GPO (User Rights Assignment). Without this right the task registers but does not start.
Second server: log restore and switchover
On srv-sql-02 the CRM instance runs in the same version, on port 14331 and under the account CORP\svc-sql$, so after a switchover neither the connection string nor the SPN changes. A backup from a newer version cannot be restored by an older one, so both instances are upgraded together. The task account gets the same set of permissions here as on srv-sql-01 plus the dbcreator role (RESTORE of an existing database can be performed only by members of sysadmin and dbcreator and by the database owner); because dbcreator allows overwriting any database, restore is better run under a separate account. The database is initialised once with a full backup through RESTORE DATABASE … WITH NORECOVERY (with MOVE when file paths differ); it stays in the RESTORING state and accepts subsequent log backups.
The restore task runs every 15 minutes, five minutes after the backup on srv-sql-01. The Restore-SqlLogs.ps1 script reads the name of the most recently restored file from the restore history in msdb (restorehistory, backupset, backupmediafamily) and restores newer *_LOG.trn files in name order, each with NORECOVERY; without history it starts from the oldest file. LSN continuity is checked by SQL Server itself: a missing file stops the restore with error 4305, and error 4326 means a backup whose changes the database already contains, which the script skips.
For a planned switchover the last log backup on srv-sql-01 is taken with BACKUP LOG … WITH NORECOVERY, CHECKSUM, so the old database enters the RESTORING state and accepts no more changes. After this file is restored on srv-sql-02 (in a failure, directly from the files that reached the share), RESTORE DATABASE [CrmDB] WITH RECOVERY is run. Then the sql-crm A record gets the address of srv-sql-02, and its TTL is lowered in advance (to 5 minutes in the example). Windows logins are created on srv-sql-02 beforehand, and SQL logins with the same SID as on srv-sql-01. After the switchover the restore task is disabled, the CRM - FULL and CRM - LOG tasks are enabled (with -Share pointing to the share on srv-sql-01) and the first full backup on the new server is started at once.
| Variant | Maximum data loss | Restore time |
|---|---|---|
| Nightly full backup only | changes of the whole day, up to 24 hours | restore of a single .bak file |
| Nightly full backup and log backup every 15 minutes | up to 15 minutes plus the time to copy the file to the share | the full backup and all log backups after it, about 60 files for a failure at 16:00 |
| The same plus restore on srv-sql-02 | as above | a dozen or so minutes: the last log backups, RECOVERY, A record change |
Restore test
RESTORE VERIFYONLY checks the completeness of the backup and the checksums but not the data structure, and the restore on srv-sql-02 confirms only the continuity of the chain. A full test is a restore under a different name (RESTORE DATABASE [CrmDB_Test] … WITH MOVE …, CHECKSUM, RECOVERY, logical file names from RESTORE FILELISTONLY) and a DBCC CHECKDB check with no messages, followed by deleting the test database.
Decisions and alternatives
| Approach | When it makes sense | Limitation |
|---|---|---|
Virtual account (NT SERVICE\MSSQL$CRM) | a single server without network resources | appears as the computer account on the network; SPNs have to be registered on the computer account |
| Ordinary domain account | no gMSA, e.g. an application that does not support managed accounts | password known to people, manual change in every service with a restart |
| gMSA, one account for instances of similar sensitivity | simple SPN, one delegation, moving instances by changing an A record | compromising one instance yields the identity on all; full isolation only with a separate server |
| Separate gMSA for instances with sensitive data (HR) | personnel data, different administrators | more accounts and SPNs to maintain |
TrustServerCertificate=True | as a stopgap until a certificate is deployed | no check of server identity; does not work with Encrypt=Strict |
| Certificate from an internal certification authority, SAN for all names | the target state, each instance separately | key in a legacy CSP, read permission for the service account, validity monitoring |
| Constrained delegation, Kerberos only | linked servers from CRM to ERP | linked servers do not support resource-based delegation |
| Unconstrained delegation | never | the service account acts on behalf of any user towards any service |
Application SQL login with CHECK_POLICY = ON | an application without Windows authentication support | password in a configuration file, lockout when one server has an old password |
| SIMPLE model | loss of changes since the last full backup is accepted | no point-in-time restore, log shipping or availability groups |
| FULL model with a log backup every 15 minutes | loss of up to 15 minutes, point-in-time restore | needs a log backup schedule, backup space and chain monitoring |
| Express with backups from Task Scheduler and restore on a second server | database within Express limits, manual switchover acceptable | no Agent, Database Mail, backup compression or automatic failover |
| Standard | size limit, buffer pool or required features | licence; in-place change with a service restart |
| Enterprise | more than 32 cores or 256 GB of buffer pool, availability groups with several databases, online operations | highest licensing cost |
Order of work
- Measure the Express limits: the allocated size of each database’s data files (from
sys.master_files,type = 0, withouttempdb) against the 50 GB or 10 GB limit depending on the version, the buffer pool and Page life expectancy during working hours; the virtual machine topology is one socket with four cores. The decision on archiving, a version upgrade or an edition change is made at 80% of the limit. - Service accounts: which accounts the database engine and the Agent run under (a name ending in
$means a managed account, and a domain account with a manual password is a migration candidate), the KDS key (Get-KdsRootKey), theGG-SQL-Hostsgroup, thesvc-sqlaccount andTest-ADServiceAccounton each server. Check:Trueon all servers. - Change the service account in Configuration Manager in a maintenance window, after moving share permissions, logins and delegation from the old account. Check: the service starts and the SPNs are already registered on the new account.
- Instance networking: a fixed port for each instance, an A record per instance, a firewall rule for UDP 1434 only from application subnets, the SQL Browser startup type Automatic (
Get-Service SQLBrowser), TCP/IP enabled on Express and Developer instances. - A certificate from the internal certification authority for each instance, with a SAN for all names; check: clients with new drivers connect without
TrustServerCertificate. - SPNs registered manually (
setspn -S) and constrained delegation for linked servers; check:setspn -Xwith no duplicates andauth_schemeequal toKERBEROSfor connections from other machines, notNTLM. - Access: logins only for directory groups, custom database roles with schema-level permissions, applications under Windows accounts. Check the members of the
sysadminandsecurityadminroles (sys.server_role_members): insysadmina disabledsa,NT SERVICE\…identifiers and theGG-SQL-Adminsgroup, insecurityadminno rows; a personal account, Domain Admins or an application login in either role needs correcting. - Recovery models: the last full backup and the last log backup of each database compared with
recovery_model_descandlog_reuse_wait_desc(msdb.dbo.backupset). A FULL database with a date in the full backup and an empty or too old last log backup is the cause of error 9002; for SIMPLE databases the absence of log backups is correct. - Backups: the
svc-sqlbackup$account with thedb_backupoperatorrole, the script and tasks in Task Scheduler, copying to a share on the second server, log restore withNORECOVERY. Check: the first full backup, the first log backups and a restore under another name withDBCC CHECKDBreturning no messages. - Shrink an oversized log (once, after a log backup, with
NOTHING) and set a fixedFILEGROWTHin megabytes.
Limitations and pitfalls
- Connection test from the server console. SSMS on the same computer connects through shared memory, so the test passes even with TCP/IP disabled and the Browser stopped. Instance availability is checked from another computer, preferably from the application subnet, with the
tcp:prefix. - Log backup outside the script. Any log backup taken outside the script breaks the chain on the second server, which reports error 4305: an ad hoc backup from SSMS, another backup program or a virtual machine backup agent that takes SQL Server log backups. An ad hoc full backup does not break the chain, and an ad hoc log backup requires the
COPY_ONLYoption. - Deleting the .ldf file. The service keeps the file open, so it can be deleted only after SQL Server is stopped, and after the next start the database does not reach the
ONLINEstate. The log can contain changes that are not yet in the data file, so replacing it with an empty file risks an inconsistent database; the size is reduced only withDBCC SHRINKFILE. - Virtual sockets in Express. When the hypervisor presents each virtual processor as a separate socket, a machine with four virtual processors looks to SQL Server like four single-core sockets, and Express uses only one processor. The solution is a topology of one socket with four cores, not an edition change.
- Certificate and delegation workarounds.
TrustServerCertificate=Truepermanently disables the check of server identity, and unconstrained delegation lets the service account act on behalf of any user. In the target state a certificate from the internal authority and delegation constrained to the SPN of the ERP instance are used.
Sources
- Configure Windows Service Accounts and Permissions - SQL Server
- Create a Key Distribution Service (KDS) Root Key
- SQL Server Browser Service (Database Engine and SSAS) - SQL Server
- Register a Service Principal Name for Kerberos Connections - SQL Server
- Linked Servers (Database Engine) - SQL Server
- Server-Level Roles - SQL Server
- Troubleshoot Full Transaction Log Error 9002 - SQL Server
- Editions and Supported Features of SQL Server 2025 - SQL Server