IBM Cloud Site Reliability Engineer Certification - Fact Sheet¶

Quick Reference¶

Certification: IBM Certified Site Reliability Engineer (SRE) - Cloud v2
Exam Code: C1000-174
Duration: 90 minutes
Questions: 60 multiple choice
Passing Score: 70%
Cost: $200 USD
Language: English
Delivery: Pearson VUE (online or test center)
Prerequisites: None (recommended 2+ years SRE/DevOps experience)
Recertification: Every 3 years
Target Audience: Site reliability engineers, DevOps engineers, operations engineers, platform engineers

Official Resources¶

Exam Domains¶

1. Monitoring and Observability (25%)¶

Monitoring strategy and implementation
Metrics collection and analysis
Log aggregation and analysis
Distributed tracing
Service Level Indicators (SLIs)
Service Level Objectives (SLOs)
Service Level Agreements (SLAs)
Error budgets
Alerting and notification strategies
Dashboard design and visualization
Synthetic monitoring
Real User Monitoring (RUM)

Monitoring Resources: - 📖 IBM Cloud Monitoring - 📖 Monitoring with Sysdig - 📖 Log Analysis - 📖 Log Analysis with LogDNA - 📖 Activity Tracker - 📖 Flow Logs for VPC - 📖 Prometheus on Kubernetes - 📖 SLI and SLO Guide - 📖 Error Budget Implementation - 📖 Alerting Best Practices

2. Incident Management and Response (20%)¶

Incident detection and triage
Incident response procedures
On-call management
Incident communication
Post-incident reviews (PIRs)
Root cause analysis (RCA)
Blameless postmortems
Incident tracking and metrics
Escalation procedures
Disaster recovery procedures
Chaos engineering principles

Incident Management Resources: - 📖 Incident Management Best Practices - 📖 PagerDuty Integration - 📖 Slack Integration - 📖 Event Notifications - 📖 Activity Tracker for Auditing - 📖 Postmortem Culture - 📖 Managing Incidents - 📖 Chaos Engineering

3. Automation and Infrastructure as Code (20%)¶

Infrastructure as Code (IaC) principles
Terraform on IBM Cloud
IBM Cloud Schematics
Configuration management
Automation scripts and tools
CI/CD pipeline design
GitOps practices
Policy as Code
Automated testing
Self-healing systems
Runbook automation

Automation Resources: - 📖 Terraform on IBM Cloud - 📖 Terraform Provider - 📖 IBM Cloud Schematics - 📖 Schematics Actions - 📖 Continuous Delivery - 📖 Toolchains - 📖 Tekton Pipelines - 📖 Ansible on IBM Cloud - 📖 IBM Cloud CLI - 📖 GitOps with ArgoCD - 📖 Runbook Automation

4. High Availability and Reliability (15%)¶

High availability design patterns
Fault tolerance and resilience
Disaster recovery planning
Backup and restore strategies
Multi-zone and multi-region architectures
Load balancing and failover
Circuit breakers and bulkheads
Retry logic and exponential backoff
Graceful degradation
Capacity planning
Performance optimization

HA and Reliability Resources: - 📖 High Availability Architecture - 📖 Disaster Recovery - 📖 Multi-Zone Regions - 📖 Load Balancers - 📖 Auto-Scaling - 📖 Kubernetes HA - 📖 Database HA - 📖 Backup Services - 📖 Reliability Patterns

5. Performance and Capacity Management (10%)¶

Performance monitoring and tuning
Capacity planning methodologies
Resource optimization
Load testing strategies
Performance profiling
Database performance tuning
Network performance optimization
Cost vs performance trade-offs
Scalability patterns
Bottleneck identification

Performance Resources: - 📖 Performance Optimization - 📖 Monitoring Metrics - 📖 Kubernetes Performance - 📖 Database Performance - 📖 Load Testing - 📖 CDN Performance - 📖 Capacity Planning

6. Container and Kubernetes Operations (10%)¶

Kubernetes cluster management
Container orchestration
Pod scheduling and placement
Resource quotas and limits
Horizontal and vertical pod autoscaling
Cluster autoscaling
Rolling updates and deployments
StatefulSets and DaemonSets
Kubernetes monitoring and logging
Helm chart management
Service mesh operations (Istio)
Container security operations

Kubernetes Resources: - 📖 IBM Cloud Kubernetes Service - 📖 Kubernetes Best Practices - 📖 Cluster Autoscaler - 📖 Horizontal Pod Autoscaler - 📖 Vertical Pod Autoscaler - 📖 OpenShift Operations - 📖 Helm on Kubernetes - 📖 Istio Service Mesh - 📖 Kubernetes Monitoring

Core SRE Concepts¶

The Four Golden Signals¶

Latency: Time to service a request
Traffic: Demand on your system
Errors: Rate of failed requests
Saturation: How "full" your service is

Resources: - 📖 Four Golden Signals

SLIs, SLOs, and SLAs¶

Service Level Indicators (SLIs): - Quantitative measures of service level - Examples: latency, error rate, throughput, availability

Service Level Objectives (SLOs): - Target values for SLIs - Example: 99.9% availability, 95^th percentile latency < 200ms

Service Level Agreements (SLAs): - Contractual agreements with consequences - Usually less stringent than SLOs

Error Budgets: - 100% - SLO = Error Budget - Used to balance innovation and reliability

Resources: - 📖 SLO Implementation - 📖 SLO Monitoring

Toil and Toil Reduction¶

Toil: Manual, repetitive, automatable work with no enduring value

Characteristics: - Manual - Repetitive - Automatable - Tactical - No enduring value - Scales linearly with service growth

Toil Reduction Strategies: - Automation - Self-service tools - Process improvement - Platform engineering

Resources: - 📖 Eliminating Toil

On-Call Best Practices¶

Reasonable on-call load (50% for tickets, <2% for pages)
Clear escalation paths
Comprehensive runbooks
Post-incident reviews
On-call compensation
Mental health support

Resources: - 📖 Being On-Call

IBM Cloud SRE Tools¶

Monitoring and Observability¶

Automation and IaC¶

CI/CD and DevOps¶

Kubernetes and Containers¶

Common SRE Scenarios¶

Scenario 1: Implementing SLOs and Error Budgets¶

Challenge: Define and implement SLOs for a microservices application.

Implementation: 1. Identify SLIs: - Availability: % of successful requests - Latency: 95^th percentile response time - Throughput: requests per second - Error rate: % of 5xx errors

Set SLOs:
Availability: 99.9% (3 nines)
Latency: 95^th percentile < 200ms
Error rate: < 0.1%
Calculate Error Budget:
100% - 99.9% = 0.1% error budget
For 30 days: 43.2 minutes of downtime
Monitor SLOs:
Set up monitoring dashboards
Configure alerts at 50%, 75%, 90% error budget consumption
Track error budget burn rate
Use Error Budget:
Deploy new features when error budget available
Freeze deployments when error budget exhausted
Focus on reliability improvements

Resources: - 📖 SLO Implementation Guide - 📖 Monitoring SLOs

Scenario 2: Building Automated Incident Response¶

Challenge: Automate detection and initial response to common incidents.

Implementation: 1. Detection: - Configure monitoring alerts in Sysdig - Set up log-based alerts in LogDNA - Implement synthetic monitoring - Create custom metrics

Notification:
Integrate with PagerDuty for on-call
Send alerts to Slack channels
Use Event Notifications service
Implement escalation policies
Automated Response:
Create Schematics actions for remediation
Use Cloud Functions for automated fixes
Implement runbook automation
Auto-scaling based on metrics
Documentation:
Maintain up-to-date runbooks
Document incident response procedures
Create troubleshooting guides
Track incident history

Resources: - 📖 Incident Response Automation - 📖 Schematics Actions

Scenario 3: Implementing GitOps for Kubernetes¶

Challenge: Deploy and manage Kubernetes applications using GitOps.

Implementation: 1. GitOps Setup: - Store all configurations in Git - Use separate repos for app and config - Implement branch protection - Use pull request workflow

Deployment Automation:
Deploy ArgoCD or Flux
Configure automatic sync
Implement health checks
Set up rollback policies
Environment Management:
Use Kustomize for overlays
Separate dev/staging/prod configs
Implement promotion workflow
Use Helm for package management
Monitoring:
Monitor sync status
Track deployment metrics
Alert on sync failures
Audit all changes via Git

Resources: - 📖 GitOps with Kubernetes - 📖 ArgoCD Documentation

Scenario 4: Capacity Planning and Auto-Scaling¶

Challenge: Implement comprehensive auto-scaling strategy.

Implementation: 1. Resource Monitoring: - Track CPU, memory, network, disk - Monitor application-specific metrics - Collect historical data - Identify usage patterns

Horizontal Scaling:
Configure Horizontal Pod Autoscaler (HPA)
Use custom metrics for scaling
Set min/max replicas
Configure scale-up/down policies
Vertical Scaling:
Implement Vertical Pod Autoscaler (VPA)
Set resource requests and limits
Monitor right-sizing recommendations
Plan maintenance windows for VPA changes
Cluster Scaling:
Enable cluster autoscaler
Configure node pools
Set cluster size limits
Monitor node utilization
Load Testing:
Perform capacity testing
Identify breaking points
Validate scaling policies
Test disaster recovery scenarios

Resources: - 📖 Kubernetes Autoscaling - 📖 Cluster Autoscaler

Scenario 5: Disaster Recovery Testing¶

Challenge: Implement and test disaster recovery procedures.

Implementation: 1. DR Strategy: - Define RTO and RPO requirements - Choose DR approach (backup/restore, pilot light, warm standby, hot standby) - Document DR procedures - Assign roles and responsibilities

Backup Implementation:
Enable automated backups for databases
Backup Kubernetes resources
Store backups in separate region
Test backup encryption
Implement backup retention policies
Failover Procedures:
Document failover steps
Automate failover where possible
Configure DNS for failover
Implement health checks
Test failover mechanisms
DR Testing:
Schedule regular DR tests
Test backup restoration
Validate failover procedures
Measure actual RTO and RPO
Update procedures based on findings
Documentation:
Maintain DR runbooks
Document test results
Track improvements
Train team members

Resources: - 📖 Disaster Recovery Planning - 📖 Backup Strategies

SRE Best Practices¶

Monitoring Best Practices¶

Monitor the Four Golden Signals: Latency, traffic, errors, saturation
Use Multiple Data Sources: Metrics, logs, traces
Create Actionable Alerts: Every alert should require action
Avoid Alert Fatigue: Tune thresholds, use alert suppression
Dashboard Design: Show what matters, avoid vanity metrics
Synthetic Monitoring: Proactive monitoring of user journeys
Distributed Tracing: Understand request flows across services

Resources: - 📖 Monitoring Best Practices

Incident Management Best Practices¶

Clear Escalation: Well-defined escalation procedures
Blameless Culture: Focus on systems, not people
Post-Incident Reviews: Learn from every incident
Action Items: Track and complete follow-up tasks
Communication: Keep stakeholders informed
Documentation: Maintain incident history
Continuous Improvement: Use incidents to improve systems

Resources: - 📖 Postmortem Culture

Automation Best Practices¶

Automate Toil: Eliminate repetitive manual work
Infrastructure as Code: All infrastructure in version control
Idempotency: Operations safe to repeat
Testing: Test automation thoroughly
Documentation: Document automation behavior
Monitoring: Monitor automation execution
Gradual Rollout: Test automation on non-production first

Resources: - 📖 Automation Philosophy

Capacity Planning Best Practices¶

Data-Driven: Base decisions on metrics
Forecasting: Project future capacity needs
Organic Growth: Plan for natural growth
Inorganic Growth: Plan for launches and campaigns
Load Testing: Validate capacity assumptions
Regular Review: Update capacity plans quarterly
Buffer Capacity: Maintain headroom for unexpected growth

Resources: - 📖 Capacity Planning

On-Call Best Practices¶

Reasonable Load: < 50% of time on-call work
Quality Runbooks: Clear, tested procedures
Post-Incident Reviews: Learn and improve
Escalation Paths: Clear when to escalate
Compensation: Fair on-call compensation
Support: Mental health and burnout prevention
Rotation: Fair rotation schedule

Resources: - 📖 On-Call Best Practices

Exam Tips and Strategies¶

General Preparation¶

Read SRE Books: Google SRE Book and Workbook
Hands-On Practice: Implement monitoring and automation
Real Incidents: Learn from real-world scenarios
Tool Proficiency: Master IBM Cloud monitoring tools
Kubernetes Operations: Deep Kubernetes operational knowledge

Key Study Areas¶

SLIs, SLOs, SLAs, and error budgets
Monitoring with Sysdig and LogDNA
Incident management procedures
Terraform and Infrastructure as Code
Kubernetes operations and autoscaling
CI/CD with Tekton and Toolchains
High availability patterns
Disaster recovery planning
Performance optimization
Capacity planning methodologies
Toil reduction strategies
Blameless postmortem culture

Common Pitfalls to Avoid¶

Confusing SLIs with SLOs
Over-alerting leading to alert fatigue
Not understanding error budget concept
Missing the importance of blameless culture
Not automating repetitive tasks
Ignoring capacity planning
Poor incident communication
Not testing DR procedures
Inadequate monitoring coverage
Not tracking toil

Scenario-Based Questions¶

Read scenarios carefully - identify key requirements
Look for SRE principles (reliability, scalability, observability)
Consider automation opportunities
Think about monitoring and alerting needs
Evaluate high availability requirements
Consider incident response procedures
Think about capacity and performance implications

Exam Day Tips¶

Focus on SRE principles, not just tools
Think about reliability and scalability
Consider monitoring and observability
Look for automation opportunities
Evaluate incident response approaches
Consider capacity planning needs
Think about error budgets
Focus on blameless culture
Review flagged questions
Manage time effectively

Additional Learning Resources¶

Books and Publications¶

📖 Google SRE Book
📖 Google SRE Workbook
📖 Google Building Secure & Reliable Systems

Training and Courses¶

Community and Support¶

Tools and Documentation¶

Important Exam Topics by Priority¶

High Priority (Study First)¶

SLIs, SLOs, SLAs, and error budgets
Monitoring with Sysdig (metrics, dashboards, alerts)
Log Analysis with LogDNA
Incident management procedures
Blameless postmortem culture
Kubernetes operations and troubleshooting
Autoscaling (HPA, VPA, cluster autoscaler)
Terraform and Infrastructure as Code
CI/CD with Tekton pipelines
High availability patterns

Medium Priority (Study Second)¶

Activity Tracker for auditing
Disaster recovery planning
Capacity planning methodologies
Performance optimization techniques
Toil identification and reduction
GitOps practices
Runbook automation
Chaos engineering principles
Service mesh operations (Istio)
Load testing strategies

Lower Priority (If Time Permits)¶

Advanced Kubernetes features
Advanced Terraform patterns
Specific CI/CD tool integrations
Advanced monitoring queries
Custom metric collection

SRE Checklists¶

Production Readiness Checklist¶

Incident Response Checklist¶

Postmortem Checklist¶

Final Preparation Checklist¶

Good luck with your IBM Cloud Site Reliability Engineer certification exam!

Remember: SRE is about balancing reliability with innovation. Focus on data-driven decision making, automation, and continuous improvement. The goal is not 100% uptime, but sustainable, reliable systems that enable rapid innovation.