Crossplane Composition Functions Deep Dive Training
Master Crossplane Composition Functions in 2 days. Hands-on training covering custom function development in Go and Python, pipeline debugging, caching, and production patterns.
Go beyond basic Compositions with this 2-day advanced training on Crossplane Composition Functions. Learn to write custom functions in Go and Python, debug complex pipelines with the pipeline inspector, optimize performance with response caching, and build production-grade function libraries with comprehensive testing strategies.
Training Details
| Duration | 2 days (16 hours) |
| Level | Advanced |
| Delivery | In-person, Live online, Hybrid |
| Certification | N/A |
Who Is This For?
- Platform engineers building custom infrastructure APIs with complex logic
- Developers writing composition functions in Go or Python
- Teams replacing patch-and-transform with programmatic composition logic
- DevOps engineers looking to extend Crossplane beyond declarative patterns
Learning Outcomes
After completing this training, participants will be able to:
- Understand the gRPC-based function architecture and execution model
- Write and test custom Composition Functions in Python and Go
- Debug function pipelines using the pipeline inspector
- Optimize function performance with response caching and TTL configuration
- Use RequiredSchemas for dynamic function behavior based on resource types
- Build CI/CD pipelines for function packaging and deployment
Detailed Agenda
Day 1: Function Architecture & Python Functions
Module 1: Composition Function Architecture
- gRPC server model — how functions receive and return resources
- RunFunctionRequest and RunFunctionResponse protocol
- Function pipeline execution order and chaining
- Desired state vs observed state in the function context
- Hands-on: Trace a function pipeline execution end-to-end with logging
Module 2: Built-in Functions Deep Dive
- function-patch-and-transform — advanced patch patterns
- function-go-templating — Go template functions and pipelines
- function-kcl — KCL language for type-safe compositions
- function-cel — Common Expression Language for inline logic
- function-auto-ready — automatic readiness detection
- Hands-on: Build a complex Composition using multiple built-in functions in a pipeline
Module 3: Writing Functions in Python
- Python Function SDK setup and project scaffolding
- Implementing the RunFunction method
- Accessing observed and desired resources
- Adding, modifying, and removing resources in the response
- Error handling and condition reporting
- Hands-on: Write a Python function that provisions infrastructure based on application labels
Module 4: Pipeline Debugging with Pipeline Inspector
- Installing and configuring the pipeline inspector
- Inspecting RunFunctionRequest and RunFunctionResponse payloads
- Step-through debugging of multi-function pipelines
- Identifying resource conflicts between pipeline stages
- Common debugging patterns — missing fields, incorrect patches, ordering issues
- Hands-on: Debug a broken multi-function pipeline and fix resource ordering issues
Day 2: Go Functions & Production Patterns
Module 5: Writing Functions in Go
- Go Function SDK and code generation
- Project structure and boilerplate setup
- Implementing RunFunction with strongly-typed resources
- Working with unstructured resources and dynamic typing
- Unit testing with the function test framework
- Hands-on: Write a Go function that enforces naming conventions and injects security defaults
Module 6: Function Testing Strategies
- Unit testing with mock RunFunctionRequest objects
- Table-driven tests for comprehensive input coverage
- Integration testing with crossplane-cli render
- End-to-end testing with real providers in CI
- Test fixtures and golden file patterns
- Hands-on: Build a complete test suite for a composition function with unit, integration, and render tests
Module 7: Performance Optimization with Caching
- Function response caching architecture
- TTL configuration — balancing freshness vs performance
- Cache key computation and invalidation triggers
- RequiredSchemas — requesting specific CRD schemas for dynamic behavior
- Measuring function execution time and cache hit rates
- Hands-on: Add caching to a function, benchmark performance impact, and configure RequiredSchemas
Module 8: Production Patterns and CI/CD
- Function packaging with OCI images
- Versioning strategy and semantic versioning for functions
- CI/CD pipeline for function builds — lint, test, build, push
- Function registry management and access control
- Canary deployment of new function versions
- Monitoring function health — gRPC metrics, error rates, latency
- Hands-on: Build a complete CI/CD pipeline that tests, packages, and deploys a composition function to a registry
Prerequisites
- Crossplane Compositions & XRDs training or equivalent experience
- Programming experience in Go or Python (both are covered)
- Kubernetes knowledge (CRDs, controllers, API machinery)
- Familiarity with gRPC concepts (helpful but not required)
Delivery Formats
| Format | Description |
|---|---|
| In-Person | On-site at your company's location, hands-on with direct interaction |
| Live Online | Interactive virtual sessions with screen sharing and real-time labs |
| Hybrid | Combination of on-site and remote sessions, flexible scheduling |
All formats include hands-on labs, course materials, and post-training support.
Ready to get started?
Request a training quote for your team — in-person, live-online, or hybrid.