Duration: Full Day (8 hours)
Prerequisites: OpenShift 101 or equivalent experience with basic OpenShift operations
Format: Hands-on lab with guided exercises
- Workshop introduction and objectives
- Lab environment overview
- Access credentials and environment setup
Hands-On Lab 1: Initial Application Deployment with Helm
- Helm Basics
- Installing and configuring Helm
- Understanding Helm charts structure
- Helm repositories and chart management
- Deploying the Application
- Installing the application using Helm
- Understanding Helm values and customization
- Verifying deployment status
- Accessing the deployed application
- Helm Chart Exploration
- Examining chart templates
- Understanding dependencies and subcharts
- Chart versioning and releases
Exercise: Deploy the workshop application using Helm and verify all components are running correctly
Hands-On Lab 2: Deployment Patterns
- Rolling Updates Deep Dive
- Configuring maxSurge and maxUnavailable
- Rollback strategies and techniques
- Health checks and readiness probes
- Blue/Green Deployments
- Implementing blue/green with Services and Routes
- Traffic switching strategies
- Database migration considerations
- Canary Deployments
- Gradual traffic shifting
- A/B testing with Routes
- Monitoring and rollback triggers
Exercise: Deploy the example application using blue/green strategy
Hands-On Lab 3: Image Management and Distribution
- Image Size Optimization
- Multi-stage builds and layer optimization
- Distroless and minimal base images
- Removing unnecessary dependencies
- Image layer caching strategies
- Image Distribution and Caching
- Image pull policies and strategies
- Node-level image caching
- Pre-pulling images to reduce cold start times
- Image distribution across nodes
- Improving Cold Startup Times
- Image pre-warming techniques
- Using init containers for image preparation
- Node image preloading strategies
- Monitoring image pull times
- Registry Optimization
- Local registry mirroring
- Image streaming and lazy loading
- Registry caching strategies
- Reducing network latency for image pulls
Exercise: Optimize application images for size and distribution, then measure improvements in cold startup times
Hands-On Lab 4: Debugging and Diagnostics
- Pod Troubleshooting
- Understanding pod lifecycle and states
- Container logs and log aggregation
- Exec into containers for debugging
- Resource constraints and OOMKilled
- Network Troubleshooting
- Service and Route debugging
- Network policies and connectivity issues
- DNS resolution problems
- Ingress/Egress traffic analysis
- Event Monitoring
- OpenShift events and their meanings
- Using
oc describeandoc get events - Alerting and monitoring dashboards
Exercise: Troubleshoot a deliberately broken application deployment
Hands-On Lab 5: Resource Management
- Resource Limits and Requests
- CPU and memory requests vs limits
- Quality of Service (QoS) classes
- Resource quotas and limit ranges
- Horizontal Pod Autoscaler (HPA)
- Configuring HPA based on CPU/memory
- Custom metrics for autoscaling
- Scaling policies and behavior
- Vertical Pod Autoscaler (VPA)
- Automatic resource recommendation
- VPA modes (Off, Initial, Auto, Recreate)
- Best practices for VPA usage
- Node Tuning
- Node resource allocation
- Taints and tolerations
- Node selectors and affinity rules
Exercise: Optimize application performance using HPA and proper resource limits
Hands-On Lab 6: Service Mesh Implementation
- Service Mesh Fundamentals
- Understanding service mesh architecture
- OpenShift Service Mesh (Istio) overview
- Sidecar proxy injection and configuration
- Service mesh control plane components
- Traffic Management
- Virtual services and destination rules
- Traffic splitting and canary deployments
- Circuit breakers and fault injection
- Request routing and load balancing
- Security and Policies
- mTLS (mutual TLS) configuration
- Authentication and authorization policies
- Service-to-service security
- Network security with service mesh
- Observability and Monitoring
- Distributed tracing with Jaeger
- Service mesh metrics and dashboards
- Request flow visualization
- Performance monitoring and analysis
Exercise: Deploy a microservices application with service mesh, configure traffic management, and implement security policies
- Review of key concepts
- Best practices summary
- Additional resources and documentation
- Open discussion and Q&A
- Workshop feedback
- OpenShift CLI (
oc) installed and configured - Access to OpenShift cluster (provided or personal)
- Basic understanding of Kubernetes concepts
- Familiarity with command-line interface
- Git client installed
- OpenShift 4.x cluster
- Admin or cluster-admin access for some exercises
- Sufficient resources (CPU, memory, storage)
- Access to container registry
- Network connectivity for pulling images
By the end of this workshop, participants will be able to:
- Deploy applications using Helm including understanding Helm charts, values, and release management
- Implement advanced deployment patterns including rolling updates, blue/green, and canary deployments
- Optimize container images for size, distribution, and faster cold startup times through image optimization and caching strategies
- Troubleshoot common issues in OpenShift deployments including pods, networking, and event monitoring
- Optimize application performance using autoscaling (HPA/VPA), resource management, and node tuning techniques
- Implement service mesh for microservices communication, traffic management, security policies, and observability
- OpenShift Documentation: https://docs.openshift.com
- Kubernetes Documentation: https://kubernetes.io/docs
- Helm Documentation: https://helm.sh/docs
- Container Image Optimization Best Practices
- OpenShift Best Practices Guide
- Lab exercise guides (provided separately)
- Sample application code repositories
- Troubleshooting scenarios and solutions
- Reference cheat sheets
- Post-workshop resources and next steps