IBM Cloud Site Reliability Engineer (C1000-179) - Practice Plan¶

Study Timeline: 6-8 Weeks¶

Week 1-2: Infrastructure & Operations Foundation¶

Focus: Infrastructure management, monitoring basics, Kubernetes/OpenShift

Study Materials¶

Review official IBM Cloud documentation for IKS and ROKS
Study Kubernetes administration and troubleshooting
Learn Terraform for infrastructure as code
Understand VPC networking and load balancing

Hands-On Labs¶

Kubernetes Cluster Management (4-6 hours)

# Create IKS cluster
ibmcloud ks cluster create vpc-gen2 \
  --name practice-cluster \
  --zone us-south-1 \
  --flavor bx2.4x16 \
  --workers 3 \
  --vpc-id $VPC_ID \
  --subnet-id $SUBNET_ID

# Practice cluster operations
kubectl get nodes
kubectl top nodes
kubectl describe node <node-name>

# Deploy sample application
kubectl create deployment nginx --image=nginx:latest
kubectl expose deployment nginx --port=80 --type=LoadBalancer
kubectl scale deployment nginx --replicas=5

Infrastructure as Code with Terraform (3-4 hours)
Create VPC with multiple subnets
Deploy Kubernetes cluster
Set up load balancers and security groups
Practice terraform plan, apply, destroy
Implement remote state management
Monitoring Setup (3-4 hours)
Deploy IBM Cloud Monitoring (Sysdig)
Configure Prometheus and Grafana
Set up log aggregation with LogDNA
Create custom dashboards

Practice Questions¶

How do you troubleshoot a pod in CrashLoopBackOff state?
What's the difference between IKS and ROKS?
How do you perform a rolling update in Kubernetes?
What are the best practices for VPC design?
How do you scale a Kubernetes cluster?

Week 3-4: Monitoring, Observability & Incident Response¶

Focus: Advanced monitoring, alerting, log analysis, incident management

Study Materials¶

IBM Cloud Monitoring documentation
Prometheus and Grafana tutorials
SRE best practices (Google SRE book recommended)
Incident response playbooks

Hands-On Labs¶

Advanced Monitoring Configuration (5-6 hours)

# Deploy Prometheus stack
kubectl create namespace monitoring
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring

# Configure custom metrics
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceMonitor
metadata:
  name: app-metrics
spec:
  selector:
    matchLabels:
      app: my-app
  endpoints:
  - port: metrics
    interval: 30s
EOF

# Set up alerts
kubectl apply -f prometheus-rules.yaml

Log Aggregation and Analysis (3-4 hours)
Configure LogDNA agents
Create log parsing rules
Set up log-based alerts
Practice log searching and filtering
Export logs to Cloud Object Storage
Incident Response Simulation (4-5 hours)
Create incident response playbook
Practice on-call rotation setup
Simulate common incidents:
- Pod failures
- High CPU/memory usage
- Network connectivity issues
- Database connection problems
Document incident timeline
Write blameless postmortem

Practice Scenarios¶

Database is experiencing high connection count - how do you diagnose and resolve?
Application latency increased from 50ms to 500ms - troubleshoot
Memory leak detected in production - identify and fix
Set up alerting for 99.9% availability SLO

Week 5: Reliability & Performance Optimization¶

Focus: SLO/SLI, error budgets, capacity planning, performance tuning

Study Materials¶

Google SRE books (chapters on SLOs and error budgets)
IBM Cloud performance optimization guides
Database performance tuning documentation
Load testing methodologies

Hands-On Labs¶

SLO/SLI Implementation (4-5 hours)

# Implement SLO tracking
# Practice calculating error budgets
# Set up SLI dashboards
# Configure SLO-based alerts

# Example: 99.9% availability SLO
# Error budget: 43.2 minutes/month downtime

Load Testing (4-5 hours)

# Install Artillery
npm install -g artillery

# Create load test
artillery quick --count 100 --num 10 https://api.example.com

# Run comprehensive test
artillery run load-test.yaml --output report.json
artillery report report.json --output report.html

Database Performance Optimization (3-4 hours)
Analyze slow queries
Create appropriate indexes
Configure connection pooling
Set up read replicas
Practice backup and restore

Auto-Scaling Configuration (3-4 hours)

# Horizontal Pod Autoscaler
kubectl autoscale deployment web-app --cpu-percent=70 --min=3 --max=20

# Custom metrics autoscaling
kubectl apply -f hpa-custom-metrics.yaml

# Cluster autoscaler
ibmcloud ks worker-pool create --enable-autoscale

Practice Exercises¶

Calculate error budget for 99.95% SLO
Design SLIs for e-commerce application
Create capacity plan for 3x traffic growth
Optimize application reducing P99 latency by 50%

Week 6: Advanced Topics & Chaos Engineering¶

Focus: Chaos engineering, disaster recovery, security, compliance

Study Materials¶

Chaos engineering principles
Disaster recovery planning
IBM Cloud security best practices
Compliance frameworks (SOC2, ISO 27001)

Hands-On Labs¶

Chaos Engineering (5-6 hours)

# Install Chaos Mesh
kubectl create namespace chaos-testing
helm install chaos-mesh chaos-mesh/chaos-mesh --namespace chaos-testing

# Network latency experiment
kubectl apply -f - <<EOF
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
  name: network-delay
spec:
  action: delay
  mode: one
  selector:
    namespaces:
      - production
    labelSelectors:
      app: web-app
  delay:
    latency: "100ms"
  duration: "30s"
EOF

# Pod failure experiment
kubectl apply -f pod-failure-chaos.yaml

# Monitor and document results

Disaster Recovery Setup (4-5 hours)
Configure multi-zone deployment
Set up cross-region backup
Test failover procedures
Document RTO and RPO
Create DR runbook
Security Hardening (3-4 hours)
Configure Pod Security Policies
Set up Network Policies
Enable RBAC
Implement secret management
Configure audit logging

Practice Scenarios¶

Design DR solution with 4-hour RTO
Implement chaos experiment for network partition
Recover from complete zone failure
Respond to security incident

Week 7: Integration & Enterprise Features¶

Focus: CI/CD, GitOps, multi-cloud, enterprise integration

Study Materials¶

IBM Cloud Continuous Delivery
GitOps with ArgoCD
OpenShift pipelines (Tekton)
Multi-cloud architecture patterns

Hands-On Labs¶

CI/CD Pipeline Implementation (5-6 hours)

# Create Tekton pipeline
kubectl apply -f - <<EOF
apiVersion: tekton.dev/v1beta1
kind: Pipeline
metadata:
  name: build-deploy-pipeline
spec:
  tasks:
  - name: build
    taskRef:
      name: buildah
  - name: test
    taskRef:
      name: pytest
    runAfter: [build]
  - name: deploy
    taskRef:
      name: kubectl-deploy
    runAfter: [test]
EOF

# Set up automated deployments
# Configure quality gates
# Implement blue-green deployments

GitOps with ArgoCD (4-5 hours)
Install ArgoCD
Configure application deployments
Set up automatic sync
Implement progressive delivery
Configure rollback automation
Multi-Cloud Architecture (3-4 hours)
Set up Transit Gateway
Configure cross-cloud connectivity
Implement global load balancing
Test failover between clouds

Practice Exercises¶

Build complete CI/CD pipeline
Implement canary deployment
Configure multi-region active-active setup
Design hybrid cloud architecture

Week 8: Exam Prep & Practice Tests¶

Focus: Review, practice tests, weak areas

Activities¶

Comprehensive Review (6-8 hours)
Review all notes and study materials
Revisit weak topics identified during study
Practice CLI commands from memory
Review Terraform configurations
Practice Exams (6-8 hours)
Take 3-4 full practice exams
Review incorrect answers thoroughly
Identify knowledge gaps
Focus study on weak areas
Hands-On Review (8-10 hours)
Complete end-to-end scenarios:
- Deploy full application stack
- Configure monitoring and alerting
- Implement auto-scaling
- Perform chaos engineering test
- Simulate and resolve incidents
- Optimize for performance and cost
Final Preparation (2-3 hours)
Review exam objectives
Practice time management
Prepare for exam day
Rest well before exam

Daily Study Schedule¶

Weekday Schedule (2-3 hours/day)¶

6:00 AM - 7:00 AM: Theory and documentation review
12:00 PM - 12:30 PM: Flashcard review, CLI practice
8:00 PM - 9:30 PM: Hands-on labs and practice

Weekend Schedule (6-8 hours/day)¶

8:00 AM - 12:00 PM: Deep-dive hands-on labs
1:00 PM - 3:00 PM: Practice scenarios and troubleshooting
4:00 PM - 6:00 PM: Review, documentation, note-taking

Key Resources¶

Official IBM Documentation¶

Training Courses¶

IBM Cloud Kubernetes Service Training
Site Reliability Engineering Foundations
Monitoring and Observability Best Practices
Chaos Engineering Fundamentals

Books (Recommended)¶

"Site Reliability Engineering" by Google
"The Site Reliability Workbook" by Google
"Chaos Engineering" by Casey Rosenthal
"Kubernetes Patterns" by Bilgin Ibryam

Practice Platforms¶

Community Resources¶

IBM Cloud Slack community
Stack Overflow (ibm-cloud tag)
Reddit r/sre
CNCF SRE communities

Hands-On Lab Environments¶

Required Tools¶

# Install IBM Cloud CLI
curl -fsSL https://clis.cloud.ibm.com/install/linux | sh

# Install plugins
ibmcloud plugin install kubernetes-service
ibmcloud plugin install container-registry
ibmcloud plugin install observe-service

# Install kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

# Install Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Install Terraform
wget https://releases.hashicorp.com/terraform/1.5.0/terraform_1.5.0_linux_amd64.zip
unzip terraform_1.5.0_linux_amd64.zip
sudo mv terraform /usr/local/bin/

# Install additional tools
npm install -g artillery  # Load testing
pip install ansible       # Automation

Practice Environment Setup¶

# Create resource group
ibmcloud resource group-create sre-practice

# Set target
ibmcloud target -g sre-practice -r us-south

# Create VPC
ibmcloud is vpc-create sre-practice-vpc

# Create Kubernetes cluster (free tier)
ibmcloud ks cluster create classic \
  --name practice-cluster \
  --zone dal10 \
  --flavor free \
  --workers 1

# Or use local Kubernetes
kind create cluster --name practice

Practice Scenarios¶

Scenario 1: Production Incident Response¶

Situation: Application experiencing 500 errors, latency spike

Tasks: 1. Check monitoring dashboards 2. Review recent deployments 3. Analyze application logs 4. Identify root cause 5. Implement fix 6. Verify resolution 7. Write postmortem

Time Limit: 30 minutes

Scenario 2: Performance Optimization¶

Situation: Application P99 latency is 2000ms, needs to be under 500ms

Tasks: 1. Baseline current performance 2. Identify bottlenecks 3. Optimize database queries 4. Implement caching 5. Configure CDN 6. Load test improvements 7. Document optimizations

Time Limit: 2 hours

Scenario 3: Capacity Planning¶

Situation: Expecting 3x traffic increase in 2 weeks

Tasks: 1. Analyze current capacity 2. Project future requirements 3. Plan scaling strategy 4. Implement auto-scaling 5. Load test at projected scale 6. Document capacity plan 7. Set up cost estimates

Time Limit: 3 hours

Scenario 4: Chaos Engineering¶

Situation: Need to validate system resilience

Tasks: 1. Define failure scenarios 2. Set up chaos experiments 3. Run network latency test 4. Execute pod failure test 5. Verify auto-recovery 6. Document results 7. Implement improvements

Time Limit: 4 hours

Scenario 5: Disaster Recovery¶

Situation: Primary region failure, need to failover

Tasks: 1. Activate DR procedures 2. Switch traffic to DR region 3. Verify application functionality 4. Monitor for issues 5. Plan failback 6. Document incident 7. Update DR runbook

Time Limit: 2 hours

Exam Day Tips¶

Before the Exam¶

Get good sleep (7-8 hours)
Eat a healthy breakfast
Arrive 15 minutes early (or log in early for online)
Have water and snacks available
Ensure quiet, distraction-free environment

During the Exam¶

Read questions carefully
Eliminate obviously wrong answers
Flag difficult questions for review
Manage time (roughly 1.5 minutes per question)
Don't spend too long on any question
Review flagged questions if time permits

Time Management¶

Total time: 90 minutes
Number of questions: ~60
Suggested pace: 1.5 minutes per question
Leave 10-15 minutes for review

What to Focus On¶

Infrastructure Management (25%):
Kubernetes/OpenShift operations
VPC networking
Terraform IaC
Load balancing
Monitoring & Observability (25%):
Sysdig/Prometheus setup
Log aggregation
Alert configuration
Dashboard creation
Reliability & Performance (25%):
SLO/SLI/Error budgets
Auto-scaling
Performance optimization
Capacity planning
Incident Response (15%):
Troubleshooting procedures
Postmortem creation
On-call management
Advanced Topics (10%):
Chaos engineering
Disaster recovery
CI/CD pipelines
Security hardening

Progress Tracking¶

Weekly Checkpoints¶

Week 1: Complete infrastructure labs
Week 2: Master Kubernetes operations
Week 3: Configure comprehensive monitoring
Week 4: Practice incident response
Week 5: Implement SLO tracking
Week 6: Execute chaos experiments
Week 7: Build CI/CD pipeline
Week 8: Pass practice exams (80%+ score)

Skills Validation¶

Deploy and manage Kubernetes cluster
Configure monitoring and alerting
Troubleshoot production incidents
Optimize application performance
Implement auto-scaling
Execute chaos experiments
Create disaster recovery plan
Build CI/CD pipeline

Ready for Exam When:¶

Scoring 85%+ on practice exams consistently
Can complete hands-on scenarios within time limits
Comfortable with all CLI commands
Can explain SRE principles clearly
Successfully completed all practice labs
Reviewed all weak areas thoroughly

Additional Study Tips¶

Use Flashcards: Create flashcards for CLI commands, concepts
Practice Daily: Consistency is more important than length
Join Study Groups: Learn from peers, share knowledge
Build Real Projects: Apply concepts to real-world scenarios
Document Everything: Keep notes, create your own cheat sheets
Review Regularly: Spaced repetition improves retention
Stay Updated: Follow IBM Cloud blogs and announcements
Ask Questions: Use forums, Slack, Stack Overflow

Good luck with your IBM Cloud Site Reliability Engineer certification!