JANUARY 2024

www.automatesql.com
Day 2: Meeting the Recovery
Time Objective

Objective:
Your organization has established a 15-minute Recovery
Time Objective (RTO) for all SQL Server instances. Your
challenge is to create a solution, or a combination of
solutions, utilizing SQL Server features to adhere to this
RTO under various disaster scenarios.

Challenge Description:
Disaster recovery planning is essential for maintaining
business continuity. SQL Server offers a suite of features
designed to protect against data loss and minimize
downtime. You are tasked with defining strategies to
meet the RTO in the face of several potential disasters,
including user errors, hardware failures, data corruption,
and catastrophic server failures.
Failure Scenarios:
User Error: An update query runs without a WHERE
clause, affecting unintended records.
Drive Failure: The drive hosting the database data files
becomes unavailable.
Data Corruption: The database is corrupted and
becomes unavailable.
Server Crash: The server hosting the SQL Server
instance crashes due to a motherboard failure.

Key Concepts:
To address these scenarios, consider leveraging the
following SQL Server features:
Point-in-Time Restore: Allows for the restoration of
data up to a specific moment before a user error
occurred. Consider trade-offs for databases using the
full recovery model vs simple recovery.
SQL Server Always On Availability Groups: Provides
high availability and disaster recovery solution to
minimize downtime in case of drive failure.
Database Page Restore: Enables the restoration of
individual pages in case of corruption, reducing
recovery time.
SQL Server Failover Cluster Instances (FCI): Offers
server-level protection by allowing another server to
take over in case of hardware failure.
Challenge Task:
1. Solution Design: For each scenario, propose a detailed
solution leveraging the aforementioned SQL Server
features. Include any additional steps or considerations
necessary to ensure the solution's effectiveness.
2. Testing Strategy: Outline a plan to test each solution,
ensuring that the 15-minute RTO can be realistically met
under each scenario.
3. Bonus Question: Identify which editions of SQL Server
offer the features you propose, highlighting any
limitations or requirements.

Resource:
Review the January 20th, 2024 edition of the DBA
Challenges newsletter for additional information.
Day 6: Favorite DBA tools

Objective:
Share and explore the favorite tools and scripts that
Database Administrators (DBAs) use to enhance their
efficiency and effectiveness in managing SQL Server
environments.

Challenge Description:
Every DBA has a toolkit that they rely on to streamline
their daily tasks, from performance tuning to database
maintenance and everything in between. In this challenge,
you're invited to reflect on your favorite tools and scripts,
sharing what makes them indispensable to your work.
Here are three of my personal favorites.
Featured Tools:
1. Plan Explorer:
Description: Enhances the analysis of SQL Server
query execution plans with a more user-friendly
interface and deeper insights than what is available
in SQL Server Management Studio (SSMS).
Why It's a Favorite: Facilitates efficient diagnosis
and optimization of queries, aiding in quicker
identification of performance issues.
2. DBATOOLS:
Description: A comprehensive suite of Powershell
scripts that automate SQL Server administration
tasks, offering commands for backups, restores,
migrations, and much more.
Why It's a Favorite: Reduces manual workload
significantly through automation, improving
productivity and accuracy in managing SQL Server.
3. Ansible:
Description: An open-source automation tool for
software provisioning, configuration management,
and application deployment. Ansible can automate
the deployment and management of SQL Server
instances across various environments.
Why It's a Favorite: Simplifies complex deployment
processes, ensures consistent environments, and
reduces the potential for human error through its
agentless architecture and use of simple YAML
syntax for automation scripts.
Challenge Task:
1. Tool/Script Exploration: Share insights about your
favorite DBA tools or scripts that have not been
mentioned. Highlight their functionalities and explain
their importance in your daily DBA activities. This can
be done in a blog post or on social media. If sharing on
LinkedIn, tag me (Luke Campbell) I’d love to hear more!
2. Comparative Analysis: Offer a comparison between one
of your preferred tools and its alternatives, detailing
why you favor it. This comparison could focus on
aspects like ease of use, feature set, community
support, or integration capabilities.
Day 12: Educating development
teams on database design

Objective:
Devise strategies to enhance the database design and
query optimization skills of development teams without
dedicated database developers, aiming to improve overall
application performance and data management practices.

Challenge Description:
Many development teams lack specialized database
development roles and there's often a gap in expertise
related to efficient database design and query
optimization. This can lead to performance issues,
scalability problems, and challenges in maintaining the
database.

Your task is to create a framework for educating and

guiding these teams in best practices for database
interaction, with a focus on crafting better-performing
queries.
Educational Strategies:
1. Structured Training Sessions:
Conduct regular training sessions covering
fundamental and advanced topics in SQL, database
design, and query optimization techniques. Use real-
world examples to illustrate best practices.
2. Code Review Sessions:
Implement peer code reviews with a focus on
database interactions. Encourage developers to
critique and learn from each other's database
queries, fostering a culture of continuous
improvement.
3. Query Optimization Workshops:
Organize hands-on workshops where developers can
bring their most challenging queries and work
collaboratively to refactor and optimize them,
applying principles learned in training sessions.
Supportive Measures:
1. Documentation and Guidelines:
Develop comprehensive documentation and coding
standards for database interactions. Include
guidelines on query optimization, index usage, and
avoiding common pitfalls.
2. Mentoring Program:
Pair less experienced developers with more
seasoned peers or external mentors who have
specific expertise in database design and
performance tuning.
3. Access to Tools and Resources:
Provide access to tools for SQL profiling and
performance monitoring, allowing developers to
analyze and optimize their queries effectively. This
step may require working with management to
increase licensing on tools use by the DBA team.
Ensure the appropriate permissions are set to
exclude unnecessary privileges to the development
team.
Challenge Task:
1. Needs Assessment:
Survey the development teams to identify specific
areas of weakness or interest related to database
design and query optimization.
2. Curriculum Development:
Based on the needs assessment, develop a tailored
training curriculum that addresses the identified
gaps and aligns with the organization's technology
stack.
3. Feedback Mechanism:
Establish a feedback loop where developers can
share their learning experiences, suggest topics for
future sessions, and report on the impact of the
training on their work.
Day 15: Hardening SQL Server
Instances - CIS vs. STIGs

Objective:
Evaluate the considerations involved in choosing between
the Center for Internet Security (CIS) benchmarks and
Security Technical Implementation Guides (STIGs) for
hardening SQL Server instances in a new secure
environment.

Challenge Description:
To fortify SQL Server environments against
vulnerabilities, the Center for Internet Security (CIS)
benchmarks and the Security Technical Implementation
Guides (STIGs) are prominent frameworks offering best
practices for security hardening. Each framework has its
unique focus, scope and implementation strategies. Your
task is to assess the considerations that must be
accounted for when deciding to implement one set of
guidelines over the other in your organization’s new
secure environment.
Key Considerations:
1. Compliance Requirements:
Assess whether your organization has specific
compliance mandates that align more closely with
either CIS benchmarks or STIGs. Certain industries or
government contracts might require adherence to
one set of standards. You can find the CIS
frameworks here and the STIG framework here.
2. Scope and Detail of Guidelines:
Compare the comprehensiveness and specificity of
the security controls recommended by CIS and
STIGs. Consider which set of guidelines offers
clearer, more actionable steps for your SQL Server
environment.
3. Ease of Implementation:
Evaluate the ease of implementing the recommended
security measures within your organization’s existing
infrastructure and operational practices. Consider
factors like available tools, documentation, and
support for automating the hardening process.
Key Considerations (continued):
4. Impact on Performance and Usability:
Consider the potential impact of hardening measures
on system performance and usability. Some security
controls might introduce trade-offs that need to be
balanced against operational requirements.
5. Update Frequency and Community Support:
Assess how frequently each set of guidelines is
updated and the level of community support
available. Regular updates are crucial for addressing
emerging threats, and a strong community can
provide valuable insights and assistance.
Sandbox Environment Setup:
To thoroughly evaluate the implications of implementing CIS
benchmarks versus STIGs, set up a sandbox environment
that includes:
SQL Server Instances: Deploy multiple instances to
apply different sets of hardening measures based on
CIS benchmarks and STIGs respectively (use
DBATOOLS, Ansible, or DSC to quickly install multiple
instances).
Testing Tools: Utilize security assessment tools capable
of measuring the compliance of your SQL Server
instances with CIS benchmarks and STIGs.
Performance Monitoring: Implement performance
monitoring tools to assess the impact of security
hardening measures on SQL Server performance.
Challenge Task:
1. Framework Comparison: Conduct a detailed
comparison of CIS benchmarks and STIGs, focusing on
their applicability to SQL Server hardening.
2. Implementation Plan: Develop a plan for implementing
selected hardening measures from both CIS and STIGs
in your sandbox environment, noting any differences in
the approach and resources required.
3. Performance and Usability Assessment: Evaluate the
impact of applying these hardening measures on SQL
Server performance and usability, documenting any
significant findings.
4. Compliance Verification: Use appropriate tools to verify
the compliance of your hardened SQL Server instances
with the selected framework, identifying any gaps or
areas for improvement. SQL Server’s policy based
management feature can help here to ensure
compliance.
Day 16: Troubleshoot random
failovers

Objective:
Diagnose and address the issue of random failovers and
SQL Server unavailability in a new 2-node Always On SQL
Server Failover Clustered Instance (FCI).

Challenge Description:
An Always On SQL Server FCI is designed to provide high
availability for SQL Server instances by utilizing Windows
Server Failover Clustering (WSFC) to facilitate automatic
or manual failover between nodes.

However, your organization's new 2-node FCI setup is

experiencing random failovers, and SQL Server becomes
unavailable when one node goes offline, indicating a
problem with the cluster configuration, resource handling,
or a deeper issue within the infrastructure.

Your task is to systematically analyze and resolve these

issues to restore the high availability and reliability of the
SQL Server environment.
Initial Steps for Analysis:
1. Cluster Error Logs:
Begin with the Windows Server Failover Clustering
(WSFC) logs. These logs can provide insights into
why the failovers are occurring, including any errors
or warnings about cluster resources or network
issues. Run cluster validation tests.
2. SQL Server Error Logs:
Review the SQL Server error logs on both nodes for
any indications of service disruptions, login failures,
or other anomalies that coincide with the failover
events.
3. System and Application Event Logs:
Examine the Windows System and Application event
logs for any related errors or warnings that might
indicate system issues contributing to the failovers.
Sandbox Environment Setup:
To replicate and troubleshoot the issue, set up a controlled
environment that mimics the production setup:
Windows Active Directory Domain Services: You’ll
need a domain in the sandbox environment to setup a
FCI.
2-Node Windows Server Failover Cluster: Configure a
test FCI with SQL Server installed on both nodes. ISCSI
disks can be used to present shared storage to multiple
VMs.
Network Simulation Tools: Implement tools to simulate
network latency, partitioning, or failures to test the
cluster's response to these conditions.
Challenge Task:
1. Failover Simulation: Systematically simulate failover
scenarios using your sandbox environment to observe
and document the cluster's behavior and identify any
conditions that trigger unintended failovers.
2. Resource Validation: Check the configuration of cluster
resources, including SQL Server, network, and storage,
to ensure they are correctly set up for high availability.
Verify that quorum settings are appropriately configured
for a 2-node cluster.
3. Network Analysis: Investigate network stability
between the nodes, including any issues with the
heartbeat signal or network configurations that could
lead to a false failover.
4. Isolation of Issue: Attempt to isolate the issue to a
specific component or configuration setting within the
cluster environment.
Day 17: Explaining acid properties
in SQL Server

Objective:
Educate a non-technical audience about how SQL Server
ensures data integrity and consistency in an OLTP
database by adhering to the ACID properties.

Challenge Description:
In the context of database systems, ACID properties
(Atomicity, Consistency, Isolation, Durability) are crucial
for ensuring reliable processing of transactions,
especially in OLTP (Online Transaction Processing)
environments where the integrity and consistency of data
are paramount.

Given the concern about potential data loss or

inconsistency due to server crashes, you must explain
how SQL Server's adherence to ACID properties helps
prevent such issues, in terms understandable to someone
without a background in ACID principles.
ACID Properties Simplified:
1. Atomicity: Think of a transaction as a package of
operations. Atomicity guarantees that either all
operations within this package succeed or none at all. If
you're shopping online, either your entire purchase goes
through (payment and confirmation), or it doesn't
happen at all.
2. Consistency: This ensures that any transaction will
bring the database from one valid state to another,
maintaining all predefined rules. For example, in a bank
transfer, consistency ensures that the total amount in
both accounts stays the same before and after the
transaction.
3. Isolation: Transactions are isolated from each other,
ensuring that they do not affect each other's execution.
4. Durability: Once a transaction is committed, it will
remain so, even in the event of a power loss, crash, or
error.

SQL Server's Implementation:

SQL Server's Role: SQL Server uses a combination of
transaction logs, checkpoints, and a write-ahead logging
(WAL) strategy to ensure that all four ACID properties
are upheld. This means that even if the server crashes,
the system knows exactly where it left off and can
either complete or roll back ongoing transactions to
maintain data integrity.
Sandbox Environment Setup:
To demonstrate SQL Server's ACID compliance:
SQL Server Developer Edition: Utilize a SQL Server
setup where you can perform transactions.
Transaction Scripts: Prepare scripts that simulate
transactions exhibiting ACID properties, such as
transferring funds between accounts for atomicity and
consistency.
Emulation Tools: Use tools or scripts to simulate server
crashes and recoveries, showing how SQL Server
maintains data integrity and consistency.
Challenge Task:
1. ACID Demonstration: Use the prepared scripts to show
ACID properties in action on SQL Server, particularly
focusing on what happens during and after a server
crash.
2. Real-World Examples: Provide relatable, real-world
scenarios for each ACID property to help illustrate their
importance in everyday database operations.
Day 18: automating sql server
instance deployments

Objective:
Streamline the deployment of 12 new standalone SQL
Server instances ensuring consistent configuration across
all instances without manually setting up each one,
leveraging automation and scripting tools.

Challenge Description:
Deploying multiple SQL Server instances with consistent
configurations can be time-consuming and prone to
human error if done manually.

As a DBA tasked with setting up 12 new standalone SQL

Server instances, your goal is to identify and utilize tools
and strategies for automating the installation and
configuration process. This approach not only saves time
but also ensures uniformity and adherence to best
practices across all instances.
Automation Tools and Strategies:
1. SQL Server Installation Wizard with Configuration File:
Initially, use the SQL Server Installation Wizard to
create a configuration file, which can be reused to
standardize subsequent installations.
2. Powershell Scripts:
Automate installation and configuration processes
through Powershell, utilizing scripts to apply
consistent settings across all instances.
3. Database Administration Tools (dbatools):
The dbatools Powershell module offers extensive
functionality for SQL Server management, including
automation capabilities for deploying and configuring
instances.
4. Desired State Configuration (DSC):
Define the desired setup of SQL Server instances
using Powershell DSC, ensuring compliance with your
configuration standards across deployments.
5. Ansible:
Ansible provides a powerful platform for automating
the deployment and configuration of SQL Server
instances. By writing Ansible playbooks, you can
automate tasks such as software installation,
configuration, and even post-installation checks,
ensuring a consistent and repeatable process across
all servers. The initial configuration file can be
parameterized by converting it to a Jinja2 format.
Sandbox Environment Setup:
Prepare an environment for testing your automation
approach:
Virtual Machines (VMs): Ready multiple VMs to mimic
the production environment for the SQL Server
instances.
Ansible Control Node: If using Ansible, set up a machine
with Ansible installed to serve as the control node for
orchestrating the deployment across all target servers.
You can find more information on how to do this here.
DBATOOLS: If using DBATOOLS, install the module on a
a VM within the environment.
Networking Configuration: Ensure all target VMs are
accessible from the Ansible control node or machine
which has DBATOOLs installed over the network.
Challenge Task:
1. Automation Strategy Development: Outline your
deployment strategy, incorporating Ansible or other
tools like Powershell and DBATOOLS for a
comprehensive automation solution.
2. Ansible Playbook Creation: Develop an Ansible
playbook and role that defines tasks for installing SQL
Server, applying the configuration file settings, and
performing any additional configurations required for
each instance.
3. Deployment Testing: Execute your Ansible playbook or
use DBATOOLS against the sandbox environment to
deploy a SQL Server instance, validating the automation
process and making adjustments as necessary.
4. Full-Scale Deployment: Apply your tested playbook or
powershell script to deploy and configure the remaining
SQL Server instances, ensuring all are set up with
identical configurations efficiently.