Kubernetes Service Mesh with Linkerd Training

Werk je met Kubernetes en wil je beter inzicht en controle krijgen over het verkeer tussen microservices?

Tijdens de Kubernetes Service Mesh with Linkerd Training leer je hoe je Linkerd inzet als service mesh binnen een Kubernetes-omgeving.

Je leert hoe Linkerd communicatie tussen services inzichtelijk maakt, beveiligt en beheersbaar maakt zonder dat je iedere applicatie daarvoor hoeft aan te passen.

We beginnen bij de vraag waarom een service mesh nodig kan zijn. Daarna ga je zelf aan de slag met het installeren van Linkerd, het toevoegen van workloads aan de mesh en het analyseren van verkeer, performance en fouten.

De training is praktisch opgezet en bedoeld voor professionals die Kubernetes al kennen en willen begrijpen hoe een service mesh in een echte cloud-native architectuur kan worden toegepast.

Voor wie is deze training?

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

Denk aan:

• Kubernetes administrators;
• DevOps engineers;
• platform engineers;
• Site Reliability Engineers;
• cloud engineers;
• software developers;
• cloud-native developers;
• solution architects;
• security engineers;
• professionals die microservice-architecturen beheren.

Basiskennis van Kubernetes is belangrijk.

Je moet begrippen als Pods, Deployments, Services en namespaces kennen. Ervaring met kubectl helpt om tijdens de labs sneller te kunnen werken.

Wat leer je tijdens deze Linkerd training?

Na afloop kun je:

• uitleggen wat een service mesh is;
• bepalen wanneer een service mesh waarde toevoegt;
• de architectuur van Linkerd begrijpen;
• Linkerd installeren binnen Kubernetes;
• Kubernetes-workloads aan de service mesh toevoegen;
• service-to-service verkeer analyseren;
• latency en success rates monitoren;
• mutual TLS gebruiken voor communicatie tussen services;
• traffic policies toepassen;
• retries en timeouts begrijpen;
• fouten en performanceproblemen onderzoeken;
• Linkerd observability gebruiken;
• Linkerd veilig beheren en upgraden;
• bepalen wanneer Linkerd wel en niet geschikt is voor een Kubernetes-platform.

Programma

Service Mesh Fundamentals

We beginnen met de vraag waarom service meshes zijn ontstaan.

In een traditionele applicatie vindt een groot deel van de communicatie intern plaats. Bij een microservicearchitectuur communiceren soms tientallen of honderden afzonderlijke services continu met elkaar.

Dat brengt nieuwe vragen met zich mee:

• welke service communiceert met welke andere service?
• hoe snel reageren services?
• waar ontstaan fouten?
• hoe beveilig je service-to-service communicatie?
• hoe pas je policies toe zonder iedere applicatie te wijzigen?

Daar komt een service mesh in beeld.

We behandelen:

• microservices;
• east-west traffic;
• service-to-service communication;
• service mesh;
• control plane;
• data plane;
• proxies;
• observability;
• security.

Linkerd architectuur

Vervolgens kijken we specifiek naar Linkerd.

Je leert hoe Linkerd binnen Kubernetes wordt opgebouwd en hoe het samenwerkt met bestaande workloads.

We behandelen onder andere:

• Linkerd control plane;
• data plane;
• sidecar proxies;
• namespaces;
• workloads;
• service discovery;
• Kubernetes-integratie.

Linkerd installeren

Je gaat zelf Linkerd installeren in een Kubernetes-cluster.

We kijken naar:

• prerequisites;
• Linkerd CLI;
• cluster checks;
• installatie;
• control plane;
• configuratie;
• health checks;
• troubleshooting.

Workloads toevoegen aan de mesh

Een Kubernetes-applicatie hoeft niet direct volledig in een service mesh te draaien.

Je leert hoe je workloads gecontroleerd toevoegt.

We behandelen:

• meshing van namespaces;
• deployments;
• proxy injection;
• automatic injection;
• rollout van bestaande workloads;
• controleren of workloads correct zijn aangesloten.

Observability

Een van de belangrijkste redenen om een service mesh te gebruiken is inzicht.

Je leert hoe Linkerd informatie geeft over communicatie tussen services.

We kijken naar:

• request rates;
• success rates;
• latency;
• service dependencies;
• metrics;
• dashboards;
• traffic visualization;
• troubleshooting.

Hiermee kun je bijvoorbeeld zien dat een applicatie traag lijkt omdat één achterliggende microservice regelmatig langzaam reageert.

Security en mutual TLS

Communicatie tussen workloads moet niet alleen werken, maar ook veilig zijn.

Je leert hoe Linkerd mutual TLS (mTLS) gebruikt voor service-to-service communicatie.

We behandelen:

• workload identity;
• certificates;
• encrypted communication;
• authentication;
• trust;
• mTLS;
• service identity.

Je leert ook wat een service mesh hiermee oplost en welke securitymaatregelen nog steeds buiten de mesh moeten worden geregeld.

Traffic management

Daarna kijken we naar de manier waarop verkeer tussen services kan worden beïnvloed.

Onderwerpen zijn onder andere:

• retries;
• timeouts;
• failure handling;
• traffic policies;
• service routing;
• resilience;
• progressive delivery-concepten.

Reliability en resilience

Microservices moeten goed omgaan met tijdelijke storingen.

We bespreken hoe Linkerd kan helpen bij:

• retries;
• timeouts;
• failoverconcepten;
• latency;
• service failures;
• betrouwbaarheid van communicatie.

Daarbij besteden we ook aandacht aan een belangrijk punt: verkeerde retry- of timeoutinstellingen kunnen problemen juist groter maken.

Monitoring en troubleshooting

Je gaat verschillende problemen onderzoeken.

Bijvoorbeeld:

• een service reageert traag;
• requests mislukken;
• een workload is niet correct toegevoegd aan de mesh;
• certificaten veroorzaken problemen;
• een proxy kan een andere service niet bereiken.

Je leert welke Linkerd- en Kubernetes-tools je gebruikt om de oorzaak te vinden.

Linkerd in productie

Tot slot kijken we naar aandachtspunten voor productieomgevingen.

We behandelen onder andere:

• high availability;
• upgrades;
• resource usage;
• monitoring;
• security;
• certificate lifecycle;
• operations;
• troubleshooting;
• rollbackscenario's.

Praktijk en labs

De training is sterk praktijkgericht.

Tijdens de dag ga je onder andere:

• een Kubernetes-cluster controleren;
• Linkerd installeren;
• workloads aan de mesh toevoegen;
• serviceverkeer bekijken;
• metrics analyseren;
• latency onderzoeken;
• mTLS controleren;
• problemen simuleren;
• problemen oplossen.

De bestaande training is ook al opgezet rond installatie, configuratie, observability, security en troubleshooting. Die goede basis behouden we, maar maken we concreter.

Wanneer gebruik je Linkerd?

We bespreken ook wanneer een service mesh niet nodig is.

Voor een klein Kubernetes-cluster met enkele eenvoudige applicaties kan een service mesh extra complexiteit toevoegen zonder voldoende voordeel.

Linkerd wordt vooral interessant wanneer je bijvoorbeeld:

• veel microservices hebt;
• inzicht wilt in service-to-service verkeer;
• mTLS centraal wilt organiseren;
• verschillende developmentteams hebt;
• betrouwbaarheid tussen services wilt verbeteren;
• een consistent platform voor observability en traffic management wilt aanbieden.

Dat maakt de training praktischer dan alleen leren welke commando's Linkerd heeft.

Wat kun je na deze training?

Na deze training begrijp je hoe een service mesh past binnen Kubernetes en kun je Linkerd installeren en gebruiken.

Je kunt workloads aansluiten, serviceverkeer analyseren, mTLS controleren en veelvoorkomende problemen onderzoeken.

Daarmee vormt de training een goede verdieping na algemene Kubernetes-, CKA-, CKAD- of platform-engineeringtrainingen.

Praktische informatie

• Duur: 1 dag
• Trainingsvorm: klassikaal, live online of in-company
• Taal: Nederlands of Engels
• Prijs: €895,- excl. btw
• Prijs incl. 21% btw: €1.082,95
• Praktische Kubernetes- en Linkerd-labs inbegrepen
• Les- en oefenmateriaal inbegrepen
• Maximaal 13 deelnemers