Introduction to Kubernetes Gateway API
In three days, learn to apply Kubernetes Gateway API systematically: compare Ingress with Gateway API, map every resource in the pinned Standard bundle, and test HTTP, gRPC, TLS, TCP, and UDP routing. Then assess controller portability and practice an Ingress migration with diagnostics and a reproducible rollback.
- Workshop levelAdvanced
- Satisfied participants2340+
- Days3
- LanguageGerman & English
- Workshop codeDW35
Workshop Details
What makes this workshop stand out
What you will learn and take away
After three days, you can use Kubernetes Gateway API with confidence:
- Map all ten Standard resources: by purpose, ownership, and trust boundary
- Test routing and failure paths: configure and verify all five Route types
- Assess controllers and migration: compare Envoy Gateway and Cilium, then practice cutover and rollback
You leave with a resource map, capability matrix, and migration checklist.
Value for your team
The workshop provides clear decision criteria:
- Clarify ownership: clearly separate platform and application team responsibilities
- Compare controllers consistently: identify portable behavior and implementation differences with the same test corpus
- Prepare a controlled migration: practice diagnostics, abort criteria, and rollback
The result is a shared controller matrix and migration checklist. Groups are limited to eight, leaving room for your project context. Corporate training can include an anonymized Ingress example. No production access is required.
Prerequisites
No prior Gateway API experience is required.
You should be comfortable with:
- Using kubectl, Kubernetes YAML, and a Linux terminal
- Working with Pods, Deployments, Services, namespaces, and Ingress, including status, events, and logs
- DNS, host and path routing, TCP/UDP, and TLS fundamentals
Not required:
- Your own cluster or production access
- Experience with any particular Gateway controller
If you need more practice with Kubernetes operations and troubleshooting, take the Kubernetes Advanced Workshop first.
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: Compare Ingress and Gateway API, understand resources, and build HTTP routing
5 topics09:00–10:00💬 Introduction Round
What changes when a team moves from Ingress to Gateway API, and when does each model fit? You compare resources, ownership, and extensibility, then map all ten Standard resources to their purpose and trust boundary. The result is a clear resource map for sound routing decisions.
A shared entry point needs clear ownership. You inspect prepared GatewayClasses, read controller assignment, status, and advertised capabilities, then create a Gateway with HTTP, HTTPS, and protocol listeners. You also assess when a ListenerSet adds useful delegation and produce a traceable infrastructure design.
12:00–13:00🥪 Lunch Break
Which request should reach which backend? You set hostnames plus matches for path, method, headers, and query parameters, split traffic across several versions by weight, and inspect parent status. Positive and negative requests show whether matching, precedence, and backend selection behave as intended.
Routing does not end with choosing a backend. You apply redirects, URL rewrites, header changes, and mirroring, test Route timeouts separately, and compare everything with the controller's advertised capabilities. A concise test matrix makes supported behavior, visible failures, and unexpected fallbacks easy to review.
16:00–16:30💭 Questions & Answers
Day 2: Route gRPC, TLS, TCP, and UDP and assess controller capabilities
5 topics09:00–10:00💭 Questions & Answers
gRPC has its own routing semantics. You create a GRPCRoute for services, methods, and headers, distribute calls across several backends, and test matching and nonmatching calls with grpcurl. Responses show whether each call reaches its intended backend or is rejected as expected; parent status confirms that the Route is accepted and its references are resolved.
With TLS passthrough, the connection stays encrypted to the backend while the Gateway routes by SNI. You send two TLS services through one listener and test correct and incorrect hostnames. Certificates, backend responses, and Route status show that the TLS streams remain cleanly separated.
12:00–13:00🥪 Lunch Break
Not every service speaks HTTP. In the prepared Cilium environment, you configure separate listeners plus a TCPRoute and UDPRoute for two echo services, then send repeatable payloads over both protocols. An intentionally incorrect port reveals where Layer 4 routing has clear boundaries.
TLS at the Gateway does not automatically protect the backend connection. You inspect Route and BackendTLSPolicy status, correct hostname and caCertificateRefs, and verify certificate identity again. Positive and negative tests show how upstream TLS and controller support work together without weakening trust.
"Experimental" means neither unusable nor already stable. Using XBackend, XBackendTrafficPolicy, and XMesh, you separate API maturity from controller support and read four versioned conformance reports by channel, mode, profile, Core, and Extended support. Your capability matrix shows demonstrated features, gaps, and open runtime checks, not an overall winner.
16:00–16:30💭 Questions & Answers
Day 3: Migrate Ingress step by step, compare controllers, and test rollback
5 topics09:00–10:00💭 Questions & Answers
A migration starts with the behavior that must remain intact. You record the routing rules and annotations of a working Ingress and use ingress2gateway as a reviewable starting point. Each dependency becomes a portable Standard mapping, controller extension, redesign, or open gap in the migration matrix.
The existing Ingress stays available while you build the Gateway, HTTPRoute, references, and TLS configuration separately. You use observedGeneration to confirm that status is current, then run the same test suite against both endpoints. Every result matches the baseline or an agreed deviation; unexplained differences block the simulated cutover.
12:00–13:00🥪 Lunch Break
Why is a Route not accepted or programmed into the data plane? You follow a fixed path from observedGeneration through Accepted, Programmed, and ResolvedRefs to events, controller logs, and active requests. For every prepared fault, you record the cause, smallest correction, and confirming retest.
A standard does not mean every controller implements every feature in the same way. Every pair runs the same HTTP, gRPC, and TLS tests on Envoy Gateway and Cilium. Differences are checked against test setup and configuration first, then version, mode, profile, or implementation; TCP and UDP remain clearly identified Cilium-only tests.
A migration is controlled only when the return path also works. Using agreed tests and abort criteria, you make a go/no-go decision, switch a simulated client, and deliberately trigger a fault. The subsequent rollback restores the verified Ingress baseline, and remaining risks are recorded.
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
ExtensionIntermediate
Introduction to Istio and Service Mesh
After three days you operate a production-ready Istio service mesh on Kubernetes. From installation through traffic management, mTLS and ambient mesh to Prometheus monitoring and Kiali visualization: everything live online and hands-on on your own cluster.
3 Days€1,665.00
ExtensionIntermediate
Introduction to Cilium
Install Cilium in a controlled way, develop network policies from observed flows, and isolate faults with a defined diagnostic sequence. This three-day workshop combines Kubernetes networking, Cilium policies, Hubble observability, and targeted eBPF diagnostics in a prepared lab environment. Positive and negative control tests show whether configuration and datapath behave as intended. No prior Cilium, Hubble, or eBPF knowledge is required.
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
Yes, if you have hands-on experience operating Ingress and a solid grasp of Kubernetes and networking fundamentals. You should be comfortable with kubectl and YAML, have practical experience with Pods, Deployments, Services, and namespaces, and understand DNS, HTTP routing, TCP/UDP, TLS, SNI, and certificate trust. You should also be able to use resource status, conditions, events, and controller logs for troubleshooting.
Prior Gateway API experience is not required. If Kubernetes networking, status conditions, and systematic troubleshooting are not yet familiar, take the Kubernetes Advanced Workshop first.
This training focuses specifically on Gateway API routing, controller evidence, and a reversible Ingress migration. The Kubernetes Advanced Workshop covers broader operational tasks and treats Gateway API as only one part of that scope. The Istio and Service Mesh Workshop owns practical service mesh operations, east-west routing, mesh mTLS, and GAMMA.
Cilium appears here only as a Gateway API implementation. CNI, Hubble, network policies, and eBPF diagnostics belong in the Cilium Workshop.
No. The workshop does not assume that Ingress must be replaced. The upstream project currently has no plans to deprecate the Ingress API. You compare its compact API and controller-specific extensions with the role-oriented Gateway API model.
Using protocol requirements, portability, ownership, and operational effort, you then decide whether an existing Ingress should remain or whether to prepare a migration.
Three days provide enough time to treat the resource model, protocol Routes, and migration with rollback as separate learning stages. On day one, you compare Ingress with Gateway API and work on HTTP routing and trust boundaries. Day two covers gRPC, TLS, TCP/UDP, backend TLS, and API maturity. Day three covers controller portability, diagnostics, parallel migration, and rollback.
In a shorter format, Route types, controller evidence, or the reversible migration would need to be reduced to demonstrations. The three-day format leaves time for positive and negative tests and for producing verifiable working artifacts.
It means the ten Gateway API resources in the Standard bundle pinned for the workshop: GatewayClass, Gateway, ListenerSet, HTTPRoute, GRPCRoute, TLSRoute, TCPRoute, UDPRoute, ReferenceGrant, and BackendTLSPolicy. You map all ten; eight feature in guided or in-depth hands-on work, while GatewayClass and ListenerSet are inspected and evaluated.
The promise does not cover every field, GEP, policy, operating mode, or vendor extension. Experimental resources and selected alpha fields are classified separately and are not presented as stable production recommendations.
The prepared runtime environments use Envoy Gateway and Cilium; you do not install the controllers during the workshop. The same HTTP, gRPC, and TLS test corpus runs on both implementations. TCP and UDP are tested separately on Cilium. You still inspect GatewayClass, controller assignment, parameters, capabilities, and status in the lab.
agentgateway and NGINX Gateway Fabric enter the comparison matrix through versioned conformance reports. The result is a traceable capability and portability matrix, not an overall ranking or purchasing recommendation.
No. The workshop does not include migration of your production resources or a production DNS cutover. You work with a prepared, sanitized HTTP(S) Ingress. ingress2gateway provides a reviewable starting point; warnings, non-portable annotations, and unsupported behavior are not hidden.
You then test parallel lab endpoints, diagnose prepared faults, and switch a simulated client. A reproducible rollback restores the saved baseline. An anonymized representative Ingress example may inform corporate training after technical review; production implementation remains a separate migration project.
If your team wants ongoing support for operations or a migration in its own environment, that is agreed separately. Our ongoing Kubernetes support covers that next step.
Our trainings usually take place from 9:00 to 16:00, both on-site and for public remote trainings.
For corporate trainings, other time models are flexible and can be worked out together.
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.