Certified Kubernetes Application Developer (CKAD) Training

Wil je leren hoe je applicaties ontwikkelt, configureert en uitrolt op Kubernetes en je voorbereiden op het officiële Certified Kubernetes Application Developer-examen?

Tijdens de Certified Kubernetes Application Developer (CKAD) Training leer je hoe je cloud-native applicaties bouwt en beheert binnen Kubernetes.

De nadruk ligt niet op het beheren van het Kubernetes-cluster zelf, maar op de applicaties die erop draaien. Je werkt met Pods, Deployments, Services, ConfigMaps, Secrets, volumes, resource management, health checks, networking, security en troubleshooting.

De training is sterk praktijkgericht. Je werkt veel met kubectl en YAML en voert opdrachten uit in echte Kubernetes-omgevingen. Daarmee ontwikkel je niet alleen de vaardigheden die je in de dagelijkse praktijk nodig hebt, maar bereid je je ook gericht voor op het officiële Certified Kubernetes Application Developer (CKAD) examen.

Voor wie is deze training?

Deze training is bedoeld voor professionals die applicaties ontwikkelen, implementeren of beheren op Kubernetes.

Denk aan:

• software developers;
• cloud-native developers;
• DevOps engineers;
• platform engineers;
• application engineers;
• Site Reliability Engineers;
• cloud engineers;
• consultants;
• professionals die zich voorbereiden op het CKAD-examen.

Je hoeft geen Kubernetes administrator te zijn.

Wel adviseren we dat je basiskennis hebt van containers, Linux en Kubernetes. Je moet tijdens de training comfortabel kunnen werken vanaf de command line.

De bestaande training noemt Linux command-line ervaring en basiskennis van containertechnologie eveneens als voorkennis.

Wat leer je tijdens de CKAD training?

Na afloop kun je:

• Kubernetes-resources maken en beheren;
• werken met Pods en multi-container Pods;
• applicaties deployen met Deployments;
• Jobs en CronJobs gebruiken;
• applicaties configureren met ConfigMaps en Secrets;
• environment variables toepassen;
• resource requests en limits instellen;
• health checks configureren;
• rolling updates en rollbacks uitvoeren;
• persistent storage gebruiken;
• Services configureren;
• applicatienetwerken begrijpen;
• securityinstellingen voor workloads toepassen;
• logs en events gebruiken;
• Kubernetes-applicaties troubleshooten;
• efficiënt werken met kubectl;
• YAML-manifests maken en aanpassen;
• je gericht voorbereiden op het CKAD-examen.

Programma

Dag 1 – Kubernetes Application Design & Build

We beginnen met de onderdelen van Kubernetes die je als developer dagelijks nodig hebt.

Je leert hoe Kubernetes een applicatie uitvoert en hoe je workloads definieert en configureert.

We behandelen onder andere:

• Kubernetes architectuur vanuit developerperspectief;
• Pods;
• namespaces;
• labels en selectors;
• YAML manifests;
• kubectl;
• declaratief versus imperatief werken.

Pods en containers

Pods vormen de basis van vrijwel iedere Kubernetes-applicatie.

Je leert:

• Pods maken;
• containers configureren;
• container commands en arguments;
• environment variables;
• container lifecycle;
• init containers;
• multi-container Pods;
• sidecar-patronen.

De bestaande CKAD-training behandelt multi-container Pods en sidecars ook al expliciet.

Deployments en workloads

Vervolgens gaan we applicaties professioneel uitrollen.

We werken met:

• Deployments;
• ReplicaSets;
• replicas;
• Jobs;
• CronJobs;
• rolling updates;
• rollbacks;
• deployment strategies.

Je leert wat Kubernetes doet wanneer een applicatie wordt bijgewerkt en hoe je gecontroleerd een nieuwe versie in productie brengt.

Applicatieconfiguratie

Configuratie hoort niet hardcoded in een container image te staan.

Je leert werken met:

• ConfigMaps;
• Secrets;
• environment variables;
• configuration files;
• volumes;
• configuratie per omgeving.

Resources en scheduling

Een Kubernetes-applicatie moet duidelijk maken hoeveel capaciteit hij nodig heeft.

We behandelen:

• CPU;
• memory;
• resource requests;
• resource limits;
• namespaces;
• quotas;
• schedulingconcepten.

Daarmee leer je voorkomen dat één workload onnodig veel resources gebruikt of andere applicaties beïnvloedt.

Dag 2 – Deployment, Observability, Security & Networking

Application Deployment

Op de tweede dag gaan we verder met het beheren van applicaties gedurende hun lifecycle.

We behandelen:

• deployment updates;
• rollout status;
• rolling updates;
• rollbacks;
• scaling;
• application lifecycle;
• deployment troubleshooting.

Je leert wijzigingen gecontroleerd uitvoeren en problemen tijdens een deployment snel herkennen.

Health checks

Kubernetes moet kunnen bepalen of een applicatie gezond is.

Je leert werken met:

• liveness probes;
• readiness probes;
• startup probes;
• HTTP probes;
• TCP probes;
• command probes.

Je leert vooral wanneer je welke probe gebruikt en wat er gebeurt wanneer een controle faalt.

Observability en troubleshooting

Een belangrijk onderdeel van CKAD is kunnen bepalen waarom een applicatie niet goed werkt.

We werken daarom veel met:

• kubectl get;
• kubectl describe;
• kubectl logs;
• events;
• container logs;
• Pod status;
• exit codes;
• resource usage;
• debugging.

De huidige training bevat application observability, logging en monitoring al als onderdeel.

Services en Networking

Applicaties bestaan meestal uit meerdere onderdelen die met elkaar moeten communiceren.

Je leert werken met:

• Kubernetes Services;
• ClusterIP;
• service discovery;
• DNS;
• ports;
• selectors;
• ingressconcepten;
• NetworkPolicies.

Je leert hoe verkeer een applicatie bereikt en hoe verschillende workloads binnen een cluster met elkaar communiceren.

Persistent Storage

Niet iedere applicatie is stateless.

Daarom behandelen we:

• volumes;
• Persistent Volumes;
• Persistent Volume Claims;
• Storage Classes;
• volume mounts;
• stateful application concepts.

Persistent Volumes en Persistent Volume Claims zitten ook al in jullie bestaande programma.

Application Security

We kijken vervolgens naar security vanuit het perspectief van de applicatie.

Onderwerpen zijn:

• ServiceAccounts;
• Secrets;
• SecurityContext;
• container privileges;
• users en groups;
• capabilities;
• read-only filesystems;
• RBAC-concepten;
• NetworkPolicies.

De focus ligt daarbij op het veilig configureren van workloads, niet op uitgebreide cluster hardening. Daarvoor hebben we de aparte CKS-training.

Praktijk en labs

Dit onderdeel zou ik bij CKAD sterk benadrukken.

CKAD is geen certificering waarvoor alleen theoretische kennis voldoende is. Je moet snel en nauwkeurig met Kubernetes kunnen werken.

Tijdens de training ga je daarom zelf:

• Pods maken;
• YAML schrijven en aanpassen;
• Deployments maken;
• applicaties schalen;
• ConfigMaps en Secrets gebruiken;
• probes configureren;
• Services maken;
• volumes koppelen;
• updates uitvoeren;
• rollbacks uitvoeren;
• fouten veroorzaken;
• problemen onderzoeken en oplossen.

Je werkt gedurende de training veel met kubectl en de command line.

Voorbereiding op het CKAD-examen

De training bereidt je gericht voor op het officiële Certified Kubernetes Application Developer (CKAD) examen van de Linux Foundation en CNCF.

Het belangrijkste verschil met veel traditionele IT-certificeringen is dat CKAD een praktijkexamen is.

Je krijgt dus niet alleen multiplechoicevragen. Je moet binnen een Kubernetes-omgeving daadwerkelijk opdrachten uitvoeren.

Daarom besteden we aandacht aan:

• snel werken met kubectl;
• efficiënt YAML aanpassen;
• documentatie gebruiken;
• troubleshooting;
• opdrachten goed lezen;
• controleren of resources correct werken;
• time management.

CKAD versus CKA

Dit onderscheid zou ik ook op de pagina zetten, omdat jullie beide trainingen aanbieden.

CKAD – Certified Kubernetes Application Developer

Gericht op de applicatie:

developer → container → Pod → Deployment → Service → configuratie → observability → applicatiesecurity.

CKA – Certified Kubernetes Administrator

Gericht op het Kubernetes-platform:

cluster → nodes → networking → storage → administration → upgrades → troubleshooting.

Ze vullen elkaar dus goed aan.

Voor developers is CKAD meestal de logische keuze. Voor engineers die Kubernetes-clusters beheren is CKA meestal relevanter.

CKAD versus KCNA

Heb je nog weinig Kubernetes-ervaring?

Dan is Kubernetes and Cloud Native Associate (KCNA) een logisch startpunt. KCNA richt zich op de basisconcepten van Kubernetes en cloud-native technologie.

CKAD gaat daarna veel verder de praktijk in.

Een logisch leerpad binnen Educate IT wordt daarmee:

KCNA → CKAD → eventueel CKA → CKS

Voor iemand die vooral platformbeheer doet:

KCNA → CKA → CKS

Wat kun je na deze training?

Na deze training kun je zelfstandig applicaties configureren, deployen en troubleshooten binnen Kubernetes.

Je begrijpt hoe Kubernetes workloads uitvoert en kunt werken met configuratie, storage, networking, security en observability.

Daarmee ben je beter voorbereid om Kubernetes in je dagelijkse werk als developer of DevOps engineer te gebruiken én om het officiële CKAD-examen af te leggen.

Praktische informatie

• Duur: 2 dagen
• Trainingsvorm: klassikaal, live online of in-company
• Taal: Nederlands of Engels
• Prijs: €1.799,- excl. btw
• Prijs incl. 21% btw: €2.176,79
• Praktische Kubernetes-labs inbegrepen
• Les- en oefenmateriaal inbegrepen
• Examengerichte oefeningen inbegrepen
• Maximaal 13 deelnemers

Certificering

Deze training bereidt je voor op het officiële:

Certified Kubernetes Application Developer (CKAD) examen van de Linux Foundation en Cloud Native Computing Foundation (CNCF).

Het officiële examen is niet inbegrepen in de trainingsprijs en kan apart worden geboekt.