Guaranteed to runFew spots left
17. – 19. August 2026
09:00 - 16:00 (CET/CEST, German time)
Online🇩🇪German
1.665,00 €
per person · plus 19% VAT
Kubernetes Operator Development with Go
After three days you build custom Kubernetes operators with Go. From Kubebuilder and Custom Resource Definitions through Reconciliation, Webhooks and Testing to production-ready deployment: all hands-on in your own cluster.
- Workshop levelSome practical experience recommended
- Satisfied participants2340+
- Days3
- LanguageGerman & English
- Workshop codeDW15
Workshop Details
What makes this workshop stand out
What you will learn and take away
After three days of operator training you independently develop Kubernetes operators with Go. Here is what you take away:
- Scaffold and implement your own operators: With Kubebuilder v4 and controller-runtime from empty project to working operator
- Secure and test operators: Admission Webhooks, CEL Validation, RBAC, and automated tests with envtest in a CI/CD-ready structure
- Deploy production-ready: Prometheus metrics, Leader Election, CRD versioning, and clean packaging with Kustomize
All exercises run in our cloud environment with a dedicated Kubernetes cluster. No local setup, no hassle. You take working operator code home with you.
Want to continue? Our Kubernetes Advanced Training deepens the cluster side where your operators run.
Why the investment pays off
Without operator know-how your team stays with manual processes or expensive commercial solutions for tasks that Kubernetes can automate natively. This training changes that:
- Automation instead of manual work: Your team can codify recurring cluster operations into Kubernetes operators, reducing error sources and response times
- Independence from third-party vendors: Instead of buying commercial operator solutions, your team builds custom operators tailored to your infrastructure
- Faster incident response: Operators with Prometheus metrics and automatic reconciliation detect and fix deviations before the on-call team has to intervene
Small groups of maximum 8 participants so we can address questions from your project context.
Prerequisites
Required:
- Solid Kubernetes knowledge: Pods, Deployments, Services, ConfigMaps, RBAC, and working with kubectl
- Experience with the Linux command line
- Basic understanding of container images and their build process
Not required:
- Go programming skills (the workshop starts with a Go crash course)
- Experience with operator development or Kubebuilder
- Knowledge of controller-runtime or client-go
Our Kubernetes Advanced Training provides the ideal preparation for the Kubernetes side. If you want to learn Go thoroughly beforehand, we recommend our Golang Training (DW17).
Workshop Agenda
Your Agenda at a Glance
Hands-on and structured. Every participant works in their own cloud environment. The agenda shows you what to expect each day.
Day 1: Go fundamentals for Kubernetes and creating first Custom Resources
5 topics09:00–10:00💬 Introduction Round
Operator development relies on Go, and this module brings you up to speed for the next three days. You write first programs using structs, interfaces and error handling, work with goroutines and channels, and see how the client-go SDK uses these patterns. By the end you can read, modify, and debug Go code.
When is it worth writing an operator, and when does a Helm chart or a simple controller suffice? This module clarifies the terms, introduces the Operator Pattern and the Operator Maturity Model, and gives you a decision framework for your own projects. You analyze two real-world examples from the CNCF ecosystem and classify them.
12:00–13:00🥪 Lunch Break
Every operator builds on Custom Resource Definitions. You create your first CRD, register it in the cluster, and work with kubectl against your new API. Along the way you learn Kubernetes API conventions: Group-Version-Resource, Spec/Status separation, and Subresources. This foundation carries the entire workshop.
Using Kubebuilder v4 you generate your first operator project and examine the scaffolded structure: main.go, api/ directory, controllers/, config/. You understand which files to customize and which to leave alone. Then you extend the generated API with custom fields and see how controller-runtime connects to the cluster.
The Reconciliation Loop is the heart of every operator. You implement your first Reconcile function that compares actual state with desired state. You work with Informers, Caches, Annotations, and the event-based model of controller-runtime. By the end your operator runs in the local cluster and reacts to changes on your Custom Resources.
16:00–16:30💭 Questions & Answers
Day 2: Deepen operator logic, secure and test it
5 topics09:00–10:00💭 Questions & Answers
Your operator creates Deployments, Services or ConfigMaps as dependent objects. How does it ensure these are cleaned up when the Custom Resource is deleted? You implement Owner References for automatic garbage collection and Finalizers for controlled cleanup logic. A common pitfall in practice that you solve confidently here.
A Reconciliation Loop is called repeatedly, not just once. If your logic is not idempotent, you create duplicate resources or infinite loops. You learn the patterns for clean CreateOrUpdate, correct status updates with StatusClient, and handling Resource Versions. Then you deliberately debug a faulty operator and find the idempotency bug.
12:00–13:00🥪 Lunch Break
Invalid input should never reach the cluster. You implement Admission Webhooks for validation and defaulting and see how cert-manager manages TLS certificates automatically. Then you use CEL Validation Rules directly in the CRD definition: lighter than webhooks and stable since Kubernetes 1.30. By the end you know when to use which approach.
An operator with cluster-admin privileges is a security risk. You generate RBAC manifests using Kubebuilder markers, apply the least-privilege principle, and protect the metrics endpoint with the new controller-runtime authentication (replacement for the discontinued kube-rbac-proxy). Result: an operator your security team approves.
How do you test an operator without needing a real cluster? With envtest you start a local API server instance and test your reconciliation logic against a real Kubernetes API. You write unit tests for individual functions, integration tests for the full loop, and see how Ginkgo and Gomega structure the tests. Finish: a test setup that fits into any CI/CD pipeline.
16:00–16:30💭 Questions & Answers
Day 3: Build, deploy and production-harden your own operator
5 topics09:00–10:00💭 Questions & Answers
Now you bring everything together. You design the API specification for your own operator: Which fields does the Spec need? Which Status Conditions do you model? Which dependent resources does the operator create? You make deliberate architecture decisions and document them before writing code. Good API design saves weeks of refactoring later.
Based on your design you implement the operator independently: scaffold the CRD, write reconciliation logic, create dependent objects, update status. You work in your own cloud environment with a dedicated cluster. The trainer supports you directly on your code. Goal: a working operator you can extend later.
12:00–13:00🥪 Lunch Break
Your CRD will evolve: new fields, changed structures, removed attributes. How do you migrate existing resources without disrupting operations? You implement Conversion Webhooks between v1alpha1 and v1beta1, define a Storage Version, and test the upgrade path. A topic that becomes relevant early in practice and is covered in almost no course.
An operator in production needs more than working logic. You integrate Prometheus metrics via the controller-runtime metrics interface, set up structured logging, and enable Leader Election for high availability. Then you debug an operator systematically using delve and cluster events. Result: your operator is ready for production use.
The final step: you build the container image, create the Kustomize manifests, and deploy your operator to the cluster. You configure readiness and liveness probes, review the generated RBAC roles, and get an outlook on the Operator Lifecycle Manager and publishing to OperatorHub.io. By the end you have walked the complete path from design to running operator.
16:00–16:30💭 Questions & Answers
Our Benefits
All from one hand!
With our high-quality trainings and workshops, you can bring yourself and your team up to date. All this with many benefits that you get from us.
- High Practical Content
- 70% hands-on, 30% theory. You work continuously with real scenarios and take working code home with you. No PowerPoint battles, but directly applicable knowledge for your projects.
- Cloud Learning Environment
- DevNinjas Dojo: Your own Kubernetes clusters and VMs for each participant in the browser. No installation, works despite VPN/proxy/firewalls. You work with dedicated resources, not in shared environments.
- Experienced Trainers
- Full-time DevOps engineers and consultants from DevNinjas lead the workshops. Not external trainers, but specialized employees actively working on client projects and sharing real-world experience.
- Small Groups
- Maximum 8 participants per workshop. Everyone gets individual support from the trainer. Your specific questions and use cases get answered, not passed over in anonymous crowds.
- Real-World Scenarios
- No toy examples or hello-world demos. You work with production-grade setups: multi-container applications, CI/CD pipelines, monitoring stacks. Directly transferable to your production environments.
- Certification
- You receive an official certificate of attendance as PDF and a verified LinkedIn badge. Document your professional development for your employer, HR, and recruiters professionally.
Testimonials
How participants experience our trainings
4.9/ 5
1047+ participant reviews · unfiltered
across all DevNinjas trainings
Trainer
5.0
Content
4.8
Hands-on
4.8
DevNinjas overall: over 1,384 participants · 207 companies · 241 workshops
Including BMW, Bundeswehr, Deutsche Bahn and many more.
"My colleagues specifically looked for a sysadmin course for Docker with another provider and had an instructor who only set up an IDE for them and then only worked on a task sheet with development tasks. I had a course with lots of background information, an instructor who had a really extensive knowledge of the whole subject matter beyond the slides, and I feel optimally informed."
Johannes Bernstein
@TRIMET Gelsenkirchen SE
"The advanced Kubernetes workshop at DevNinjas really helped me grow professionally. The content was practical and excellently prepared, so even complex topics like RBAC, network policies and Ingress were conveyed in an understandable and directly applicable way. The deep expertise of the trainer was especially impressive and noticeable in every session. I can recommend this workshop to anyone who wants to use Kubernetes in production!"
Marius Büttner
@Siemens AG
"From my perspective, the workshop had the right speed and an appropriate level of challenge. The subject matter was explained clearly by the instructor and practically consolidated with well-distributed exercises. Adjusting the workshop focus to the participants wishes was not a problem. Valuable practical experiences were shared, and even more specific questions were gladly answered. The instructor's professional expertise and extensive practical experience on the subject gave this workshop a special quality."
S. Kaiser
@forcont business technology GmbH
"The seminar gave a very good overview of Docker administration, with a look at Kubernetes and how this knowledge simplifies everyday work. Many small, easy-to-follow examples with hands-on exercises and a focus on best practice consolidated what we learned. The instructor had an answer to every question, and for very specific questions he came back with a fitting example. The alternation between introductions and exercises was very well organised."
Sebastian A.
@DMI GmbH & Co. KG
"The workshop was very informative and I could immediately spot the mistakes I had made in past Docker projects. Before, I lacked the theory and the fundamentals, so I had only been acting on best practice. Now I can write stable Dockerfiles and Docker Compose setups and secure them properly. A very good workshop that was also a lot of fun!"
Timon Strangfeld
"In the workshop the most important Docker and Kubernetes topics were put together, prepared and explained superbly. The exercises fit precisely and were very well chosen in terms of difficulty. I am very satisfied with how much I learned in the five days and feel well prepared for upcoming tasks at work. Sure, you can teach yourself a lot on your own with AI tools, but without the workshop I would not have gained this overview or worked through so many exercises independently."
Christine L.
"Nico is a very friendly and technically skilled instructor. He answered all questions well. You quickly notice that he combines academic expertise with many years of professional practice."
Philipp van Wickevoort Crommelin
@parcIT GmbH
"The workshop gave me a very good insight into Kubernetes and made working with containers much clearer. Nico delivered the content in a practical and well-structured way, so I could quickly find my way around. The hands-on exercises in particular helped me apply what I learned directly. For anyone looking for a solid introduction to Kubernetes, this workshop is definitely recommended."
Daniel Hagen
@DKB Service GmbH
"I really enjoyed the Docker & Kubernetes workshop at DevNinjas. Nico explained the complex topics around containers and orchestration in a very understandable and practical way. The mix of theory and hands-on exercises was perfect for being able to apply everything directly. I was able to take a lot away for my everyday work and now feel significantly more confident working with Docker and Kubernetes."
Dominik Kneissl
@Siemens Healthineers
"The Docker workshop at DevNinjas was an all-round success. The content was clearly structured and practically delivered, including meaningful hands-on exercises. I took away a lot and feel significantly more confident working with Docker. Even more complex topics like multi-stage builds and networking were explained in an understandable way. A clear recommendation for anyone who really wants to understand Docker!"
Daniel Müller
@Siemens Healthineers
"I really enjoyed the Docker workshop at DevNinjas! The content was well structured and clearly explained, even for beginners like me. The mix of theory and hands-on exercises was especially helpful for trying Docker directly. By the end, I was able to build my own images, configure containers and set up networks. Absolutely recommended for anyone who wants to learn Docker!"
Pascal Schunk
@OEDIV
"The "Docker & Kubernetes Bundle" training provided me with solid, practical knowledge for everyday work and enabled me to handle Docker and Kubernetes professionally. The excellently structured material offers real added value, even beyond the workshop. The combination of technical depth and interactive delivery by the trainer rounded off the whole experience. An experience that continues to help me even after the training."
Swen Strangfeld
@Bundesdruckerei GmbH
"It was fun and I learned a lot that I can actually apply directly in my company. The trainer's approach was very hands-on, and he repeatedly brought in real-world examples."
Felix R.
@Dirk Rossmann GmbH
"I can recommend the Docker workshop at DevNinjas without reservation! The training was excellently structured: theory and practice complemented each other perfectly. The trainer always answered questions competently and clearly, making even more complex topics easily accessible. I was especially impressed by the professionally designed workshop materials, which are very useful as a reference even after the course. Overall, a thoroughly successful learning experience!"
Lukas Graf
@Bundeswehr
"The seminar was superbly prepared, the group pleasantly small and the materials first-class. An excellent instructor who knows the subject inside out, takes time for the participants and answers questions in detail. The learning material alternated in a balanced way between theory and hands-on exercises that were timed excellently."
Kevin H.
@Oest Holding GmbH
"Competent instructor. Individual approach to problems and topics. Interesting structure. Highly recommended to get an in-depth insight into the Docker world. The workshop was definitely worth it. Thanks!"
H. Hillebrand
@PFSt NRW
Continue Learning
Related Workshops for You
Foundation
Intermediate
Kubernetes Advanced
Two-day Kubernetes Advanced Training for production-ready deployments. You'll learn StatefulSets for databases, RBAC for security, HPA and VPA for auto-scaling, and Prometheus and Grafana for monitoring. Perfect after the introductory course or with comparable Kubernetes experience. Live online in groups of up to 8 participants.
2 Days€1,110.00
FoundationBeginner
Introduction to Golang
After three days you will write safe, concurrent Go code and understand why Go powers Docker, Kubernetes, and Terraform. From language fundamentals through goroutines and channels to your own HTTP server and CLI tool: all hands-on in your own cloud environment.
3 Days€1,665.00
ToolingIntermediate
Introduction to Kubernetes Helm
Develop production-ready Helm charts in 3 days: From installation through OCI registry publishing to GitOps integration. You create custom charts, test with helm-unittest, and deploy multi-environment setups. All exercises run on dedicated Kubernetes clusters in the DevNinjas Dojo.
3 Days€1,665.00
Your Contact
Vincent Sturm
Key Account Manager
Looking for the right Kubernetes or DevOps training for your team? Vincent personally advises you on open workshops, certification prep and customized in-house training. He can also connect you with our consulting services. Get in touch with him directly.
Frequently asked questions
No, Go experience is not required. The workshop starts with a Go crash course covering the concepts relevant to operator development: structs, interfaces, error handling, and concurrency basics.
However, you should have experience with at least one programming language (e.g. Python, Java, TypeScript). You will learn Go syntax in the workshop, but basic concepts like variables, functions, and control structures should be familiar to you. If you want to learn Go thoroughly beforehand, we recommend our Golang Training (DW17).
kubectl experience is enough. You should be comfortable with kubectl, know the core concepts (Pods, Deployments, Services, ConfigMaps, RBAC), and create YAML manifests routinely. The programmatic API SDK client-go is not required.
You learn how to work with client-go and controller-runtime in the workshop: from reading and writing resources to Informers and Caches in the reconciliation loop. So you need no prior Go API knowledge, just the cluster fundamentals you bring from daily kubectl work.
Helm charts package and deploy Kubernetes resources. This is enough for most applications. An operator becomes useful when your application needs ongoing management logic: automatic backups, failover, scaling based on custom rules, or managing resources outside the cluster.
The rule of thumb: if you regularly need to intervene manually after deployment, that signals an operator. If kubectl apply and a few values are sufficient, stick with Helm. In the workshop we work through this distinction using concrete scenarios so you can make the right decision for your projects.
Both tools use controller-runtime as their foundation and produce similar project structures. Kubebuilder is the official CNCF project for Go-based operators and focuses on Go as the only language. The Operator SDK builds on top of Kubebuilder and adds Ansible and Helm-based operators plus the Operator Lifecycle Manager (OLM).
In the workshop we use Kubebuilder v4 because it offers the most direct path to understanding the underlying mechanics. Everything you learn with Kubebuilder transfers 1:1 to the Operator SDK.
After three days you can:
- Scaffold your own operators and implement them with Kubebuilder from CRD to reconciliation loop
- Create dependent resources (Deployments, Services, ConfigMaps) and manage them with Owner References
- Set up validation and defaulting with Admission Webhooks and CEL Rules
- Write automated tests with envtest and integrate them into a CI/CD pipeline
- Make operators production-ready with Prometheus metrics, Leader Election, and CRD versioning
Realistically: After three days you are not an operator expert, but you can independently develop, test, and deploy operators for your projects. Deep expertise comes with applying what you learned in your own scenarios.
Yes, the Operator SDK supports Ansible-based and Helm-based operators in addition to Go. For simple use cases (e.g. a Helm chart with status reporting) this can be sufficient.
In practice you quickly hit limitations with Ansible and Helm: complex reconciliation logic, fine-grained error handling, and performance with many Custom Resources are much better solved with Go. Most production-grade operators in the CNCF ecosystem (cert-manager, Prometheus Operator, ArgoCD) are written in Go. That is why this workshop deliberately uses Go as its foundation.
Testing is a dedicated block on day two, not a side topic. You write unit tests for individual functions, integration tests with envtest (a local API server without a real cluster), and structure everything with Ginkgo and Gomega.
The result is a test setup you can directly adopt into your CI/CD pipeline. Most operator courses treat testing as an afterthought at best. We consider it the difference between a prototype and a production-ready operator.
All practical exercises take place in the DevNinjas Dojo, our browser-based cloud learning environment. Every participant receives dedicated resources: own Kubernetes clusters, VMs, containers (depending on the workshop topic). You work not in a shared environment, but have full control over your own infrastructure.
Benefits:
- Your own clusters & servers: You get dedicated resources for your exercises
- No software installation required: Everything runs in your browser
- Works everywhere: Even in strict enterprise networks with VPN, proxy, and firewalls
- Open protocols: SSH, HTTPS, standardized web terminals (no proprietary client)
- Ready immediately: Login and start with the exercise right away
You only need a modern browser (Chrome, Firefox, Edge) and internet access. The Dojo is available to you throughout the entire workshop.
We recommend a maximum of 8 participants per training to ensure individual attention for each participant. For corporate trainings, arrangements for larger groups are possible.
Yes, upon completion you will receive an official certificate of attendance from DevNinjas as PDF. This confirms your successful participation and the topics covered. The certificate is perfect for conversations with your employer and your personnel file.
Additionally, you will receive a verified digital badge that you can directly embed in your LinkedIn profile (section "Licenses & Certifications"). The badge follows the Open Badges 2.0 standard and is verifiable via QR code at any time. This way you showcase your qualification and position yourself with recruiters.