Microservices Trainingen in Leiden

Confluent Apache Kafka is een bedrijfsgerichte, gedistribueerde event streaming-platform dat is gebaseerd op Apache Kafka. Het ondersteunt data-pipelines met hoge doorvoersnelheid en fouttolerantie, evenals real-time streaming-applicaties.

Deze interactieve training wordt geleid door een ervaren instructeur (online of ter plaatse) en is bedoeld voor engineers en beheerders op middenniveau die Confluent Kafka-clusters in productieomgevingen willen implementeren, configureren en optimaliseren.

Na afloop van deze training zullen deelnemers in staat zijn tot het volgende:

• Het installeren, configureren en beheren van Confluent Kafka-clusters met meerdere brokers.
• Het ontwerpen van hoogbeschikbare setups met behulp van Zookeeper en replicatiemethoden.
• Het afstemmen van de prestaties, het monitoren van relevante metrics en het toepassen van herstelstrategieën.
• Het beveiligen, schalen en integreren van Kafka binnen bedrijfsomgevingen.

Vorm van de cursus

• Interactieve presentaties en discussies.
• Uitgebreide oefeningen en praktijkopdrachten.
• Praktische implementatie in een live-labomgeving.

Mogelijkheden voor maatwerk aanpassing

• Indien u een op maat gemaakte versie van deze cursus wenst, kunt u contact met ons opnemen om dit te regelen.

Confluent Apache Kafka is een gedistribueerd platform voor het streamen van gebeurtenissen, speciaal ontworpen voor data-pipelines met hoge doorvoercapaciteit en fouttolerantie evenals realtime analytics.

Deze training wordt begeleid door een instructeur en kan zowel online als op locatie worden gevolgd. Ze is bedoeld voor systeembeheerders en DevOps-professionals met gemiddelde kennis die Confluent Apache Kafka willen installeren, configureren, monitoren en problemen oplossen.

Aan het einde van deze training zullen deelnemers in staat zijn tot het volgende:

• Inzicht krijgen in de componenten en architectuur van Confluent Kafka.
• Kafka-brokers, Zookeeper-quorums en relevante diensten implementeren en beheren.
• Gevorderde instellingen configureren zoals beveiliging, replicatie en prestatie-optimalisatie.
• Beheer- en monitoringtools gebruiken om Kafka-clusters te onderhouden.

Vorm van de cursus

• Interactieve lezingen en discussies.
• Veel oefeningen en praktische opdrachten.
• Praktijkgerichte implementaties in een live-labomgeving.

Mogelijkheden tot maatwerk aanpassing

• Wilt u een op maat gemaakte training? Neem dan contact met ons op om de mogelijkheden te bespreken.

Deze door een instructeur geleide live-training in Leiden (online of op locatie) is bedoeld voor Java-ontwikkelaars met basiskennis die Apache Kafka willen integreren in hun applicaties, zodat deze betrouwbare, schaalbare en hoogcapaciteit communicatie kunnen verwezenlijken.

Aan het einde van de cursus zullen deelnemers onder andere kunnen:

• De architectuur en kernonderdelen van Kafka begrijpen.
• Een Kafka-cluster instellen en configureren.
• Berichten produceren en consumeren met Java.
• Kafka Streams toepassen voor realtime verwerking van data.
• Zorgen voor fouttolerantie en schaalbaarheid in Kafka-applicaties.

Deze door een instructeur geleide live-training (online of op locatie) is bedoeld voor ontwikkelaars en architecten met een gemiddelde tot gevorderde kennis, evenals DevOps-professionals die ervaring willen opdoen in het ontwerpen, implementeren en beheren van robuuste toepassingen door gebruik te maken van microservices, containers en CI/CD-pijplijnen.

Aan het einde van deze training kunnen deelnemers:

• De principes van microservices-architectuur begrijpen en toepassen.
• Containergebaseerde applicaties implementeren en beheren met Docker en Kubernetes.
• CI/CD-pijplijnen opzetten en optimaliseren voor geautomatiseerde implementatie.
• De beste praktijken op het gebied van beveiliging, monitoring en observability toepassen.

Deze door een instructeur geleide training in Leiden (online of op locatie) is bedoeld voor ervaren platform engineers en DevOps-professionals die willen leren hoe ze applicaties kunnen schalen met behulp van microservices en Kubernetes.

Aan het einde van deze training zijn de deelnemers in staat tot:

• Het ontwerpen en implementeren van schaalbare microservices-architecturen.
• Het deployen en beheren van applicaties op Kubernetes-clusters.
• Het gebruik van Helm-charts voor een efficiënte service-implementatie.
• Het monitoren en onderhouden van de status van microservices in productie.
• Het toepassen van best practices op het gebied van beveiliging en compliance binnen een Kubernetes-omgeving.

Deze door een instructeur geleide live-training in Leiden (online of op locatie) is bedoeld voor Java-ontwikkelaars met een gemiddelde kennisniveau die microservice-gebaseerde applicaties willen ontwerpen, ontwikkelen, implementeren en onderhouden met behulp van Java-frameworks zoals Spring Boot en Spring Cloud.

Aan het einde van deze training zullen deelnemers in staat zijn te:

• De principes en voordelen van microservices-architectuur begrijpen.
• Microservices bouwen en implementeren met Java en Spring Boot.
• Dienstontdekking, configuratiebeheer en API-gateways realiseren.
• Microservices effectief beveiligen, monitoren en schalen.
• Microservices implementeren met Docker en Kubernetes.

Deze door een instructeur geleide, live-training in Leiden (online of op locatie) is bedoeld voor ervaren ontwikkelaars die applicaties willen bouwen, implementeren en schalen met behulp van microservices gebaseerd op NodeJS en React.

Aan het einde van deze training zullen deelnemers in staat zijn om:

• Applicaties te ontwikkelen, implementeren en schalen door gebruik te maken van verschillende microservices.
• Een server-side gerenderde React-applicatie te bouwen.
• Meerdienstige applicaties naar de cloud te deployen met behulp van Docker en Kubernetes.
• Applicatietests uit te voeren op microservices.

Deze door een instructeur begeleidde, live training in Leiden (online of op locatie) is gericht op ontwikkelaars, integratie-architecten en systeembeheerders die de kunst van geavanceerde integratiepatronen en -technieken met Apache Camel willen beheersen.

Aan het einde van deze training kunnen deelnemers:

• Geavanceerde integratiepatronen en -technieken begrijpen.
• Complexe routing en transformaties implementeren.
• Prestaties en schaalbaarheid optimaliseren.
• Fouten en uitzonderingen afhandelen in complexe integratiescenario's.
• Apache Camel integreren met verschillende technologieën en platforms.

Deze interactieve training onder begeleiding van een instructeur in Leiden (online of op locatie) is bedoeld voor ontwikkelaars met een gemiddelde kennisniveau die big data-toepassingen willen bouwen met behulp van Apache Kafka.

Aan het einde van de training zullen de deelnemers in staat zijn om:

• Kafka-producers en -consumers te ontwikkelen voor het verzenden en lezen van gegevens uit Kafka.
• Kafka te integreren met externe systemen via Kafka Connect.
• Streamingtoepassingen te schrijven met behulp van Kafka Streams en ksqlDB.
• Een Kafka-clienttoepassing te verbinden met Confluent Cloud voor cloudgebaseerde implementaties van Kafka.
• Praktische ervaring op te doen via hands-on oefeningen en reële use cases.

Deze door een instructeur geleide training in Leiden (beschikbaar online of ter plaatse) richt zich op ontwikkelaars met gemiddelde tot gevorderde kennis die hun vaardigheden verder willen ontwikkelen bij het bouwen van microservices met Spring Boot, Docker en Kubernetes.

Aan het einde van de training zullen deelnemers onder andere kunnen:

• De principes achter microservices-architectuur begrijpen.
• Productieklare microservices ontwikkelen met behulp van Spring Boot.
• De cruciale rol van Docker bij het containeriseren van microservices inzien.
• Kubernetes-clusters configureren om microservices te implementeren en te beheren.

Deze praktijkgerichte training onder leiding van een instructeur in Leiden (online of ter plaatse) is bedoeld voor ontwikkelaars en DevOps-engineers op intermediair niveau die ervaring willen opdoen met het bouwen, implementeren en beheren van microservices met behulp van Spring Cloud en Docker.

Aan het einde van deze training zijn deelnemers in staat tot:

• Microservices ontwikkelen met Spring Boot en Spring Cloud.
• Applicaties containeriseren met Docker en Docker Compose.
• Dienstdetectie, API-gateways en onderlinge communicatie tussen microservices implementeren.
• Microservices in productieomgevingen bewaken en beveiligen.
• Microservices implementeren en beheren met Kubernetes.

Deze live training onder leiding van een instructeur in Leiden (online of op locatie) richt zich op ontwikkelaars en architecten met midden- tot hoog niveau kennis die native Java-applicaties en microservices willen creëren met Quarkus, rekening houdend met optimaal geheugengebruik en snelle starttijd.

Aan het einde van deze training zullen deelnemers in staat zijn tot:

• Het ontwikkelen van krachtige, lichtgewicht native Java-applicaties met Quarkus.
• Het bouwen en implementeren van RESTful-services en microservices-architecturen.
• Het gebruiken van GraalVM voor native compilatie en het optimaliseren van de starttijd en geheugenefficiëntie.
• Het verpakken en containeriseren van applicaties voor gebruik in Kubernetes- en OpenShift-omgevingen.

Dompel uzelf onder in RabbitMQ, de open-source berichtenbroker die wereldwijd betrouwbare en hoogperformante gedistribueerde systemen ondersteunt. In deze cursus komen de basisconcepten van het AMQP-protocol aan bod, evenals strategieën voor berichtrouting, clusterconfiguratie en instellingen voor hoge beschikbaarheid. Deelnemers leren hoe ze wachtrijen beheren, gespiegelde werkbelastingen configureren, een uitgebalanceerde failover-omgeving opzetten en veiligheidsmaatregelen treffen – inclusief integratie met de REST API en managementplugins. Na afloop beschikken ze over het zelfvertrouwen om productieklaar berichteninfrastructuren op Linux te implementeren.

Deze door een instructeur geleide training in Leiden (online of op locatie) is bedoeld voor softwarearchitecten en webontwikkelaars die RabbitMQ als berichtenmiddleware willen gebruiken en Java met Spring toepassen bij het ontwikkelen van applicaties.

Aan het einde van deze training zullen deelnemers in staat zijn om:

• Java en Spring te gebruiken samen met RabbitMQ voor het bouwen van applicaties.
• Asynchrone, berichtengestuurde systemen te ontwerpen met behulp van RabbitMQ.
• Wachtrijen, topics, exchanges en bindingen te maken binnen RabbitMQ.

In deze praktijkgerichte training onder begeleiding van een instructeur in Leiden leren de deelnemers hoe ze RabbitMQ installeren, configureren en beheren, waarna ze berichtenfunctionaliteit van RabbitMQ integreren in diverse voorbeeld-.NET-applicaties.

Aan het einde van deze training zullen de deelnemers onder andere kunnen:

• RabbitMQ instellen, configureren en beheren.
• Inzicht verwerven in de rol van RabbitMQ bij het ontwerp en de implementatie van een microservices-architectuur.
• Begrijpen hoe RabbitMQ zich onderscheidt van andere architecturen voor berichtenwachtrijen.
• RabbitMQ als broker instellen en gebruiken voor asynchrone en synchrone berichtverwerking in zakelijke .NET-applicaties.

Deze door een docent begeleide, live-training in Leiden (online of op locatie) richt zich op ontwikkelaars en software-engineers die RabbitMQ willen gebruiken voor communicatie tussen microservices via berichtverwerking, evenals voor geavanceerde implementaties en probleemoplossing.

Aan het einde van deze training zullen deelnemers in staat zijn om:

• De benodigde omgeving in te richten om geavanceerde berichtverwerkingsoplossingen met RabbitMQ te ontwikkelen.
• Te begrijpen hoe een gedistribueerde microservices-architectuur met behulp van RabbitMQ kan worden ontworpen.
• Gevorderde configuratie, beveiliging, netwerkinstellingen, hoge beschikbaarheid en replicatie te implementeren.
• De meest voorkomende problemen bij installaties van RabbitMQ te herkennen en op te lossen.
• Werkwijzen voor geheugenoptimalisatie, flow control en performance-tuning toe te passen.
• Gebruik te maken van diverse geavanceerde probleemoplossingstechnieken.

Istio is een open-source service mesh die op Kubernetes draait en zorgt voor beveiligde, waarneembare en beheersbare communicatie tussen microservices. Door gebruik te maken van de door Envoy aangestuurde sidecar-proxies van Istio kunnen teams beleidsregels afdwingen, communicatie beveiligen met mTLS, gedetailleerde inzichten verkrijgen over het verkeer en de betrouwbaarheid van hun systemen op schaal verbeteren.

Deze live-training onder leiding van een instructeur (online of ter plaatse) is bedoeld voor engineers met voldoende voorkennis die microservices-applicaties willen implementeren, beveiligen en beheren met Istio op Kubernetes.

Na afloop van deze training zullen deelnemers in staat zijn om:

• Istio te installeren en te configureren op Kubernetes-clusters.
• De kernconcepten van service meshes te begrijpen, waaronder verkeersbeheer, beveiliging en waarneembaarheid.
• Microservices-applicaties te implementeren binnen een Istio-service mesh.
• Communicatie tussen services te beveiligen met mutual TLS (mTLS) en principes van Zero Trust.
• Microservices te monitoren, traceren en probleemoplossend te werk te gaan met behulp van Prometheus, Grafana en Jaeger.
• Istio te integreren met Calico voor geavanceerde netwerkbeleidsregels en extra beveiliging.

Opbouw van de cursus

• Interactieve lezingen en discussies.
• Veel oefeningen en praktische opdrachten.
• Praktische implementatie in een live-labomgeving.

Mogelijkheden voor cursuscustomisatie

• Wilt u een op maat gemaakte training aanvragen? Neem dan contact met ons op om de mogelijkheden te bespreken.

Tijdens deze begeleide, live-training in Leiden (online of op locatie) leren deelnemers hoe ze een Python-applicatie kunnen loskoppelen en vervolgens integreren met het RabbitMQ-berichtenplatform om gedistribueerde cloudapplicaties of microservices te creëren.

Aan het einde van deze training zijn de deelnemers in staat tot:

• RabbitMQ instellen, configureren en beheren.
• Het belang van RabbitMQ begrijpen bij het ontwerp en implementeren van een microservicesarchitectuur.
• Bewust zijn van de verschillen tussen RabbitMQ en andere berichtendistributiearchitecturen.
• RabbitMQ configureren als broker voor zowel asynchrone als synchrone berichtenverwerking in echte Python-applicaties.

Apache Camel biedt een robuust framework voor het integreren en routeren van bedrijfsapplicaties. De cursus behandelt essentiële concepten zoals routering, berichttransformatie, strategieën voor foutafhandeling, componentconnectoren, Enterprise Integration Patterns en transactiebeheer. Ook wordt uitgelegd hoe ontwikkelaars route-definities configureren, beans met elkaar koppelen, beheersing van paralleliteit toepassen en monitoringtechnieken implementeren. Deelnemers leren vervolgens betrouwbare communicatielagen voor microservices te ontwerpen waarmee datastromen efficiënt kunnen worden afgehandeld.

Deze praktijkgerichte training onder leiding van een instructeur in Leiden (online of op locatie) is bedoeld voor ontwikkelaars die willen leren hoe ze een API kunnen ontwikkelen, testen, debuggen en implementeren binnen het Apigee API Platform van Google Cloud.

Aan het einde van deze training zullen de deelnemers in staat zijn om te:

• Een ontwikkelomgeving op te zetten met alle benodigde middelen voor het ontwikkelen van een API.
• De beschikbare hulpmiddelen binnen Apigee Edge te begrijpen en toe te passen.
• Een API te bouwen en te implementeren op Google Cloud.
• API-fouten te monitoren en te debuggen.
• De analytics- en machine learning-tools van Google Cloud in te zetten om hun API’s intelligenter te maken.

Apigee Edge, dat is gebaseerd op Java, maakt het mogelijk om beveiligde toegang tot uw diensten te bieden via een duidelijke en consistente API – ongeacht de onderliggende implementatie van uw diensten. Een consistente API:

• Vergemakkelijkt het gebruik van uw diensten door applicatieontwikkelaars.
• Maakt het mogelijk om de onderliggende implementatie te wijzigen zonder dat dit gevolgen heeft voor de openbare API.
• Stelt u in staat gebruik te maken van analytische functies, monetiseringsopties, het ontwikkelaarsportaal en overige mogelijkheden die Apigee Edge biedt.

Doelgroep

Dit cursusprogramma is bedoeld voor ingenieurs, architecten en ontwikkelaars die Apigee Edge in hun projecten willen toepassen.

In deze cursus maakt u een volledige, praktijkgerichte reis door het ontwerpen, bouwen en beheren van cloud-native microservices. De nadruk ligt op de praktische implementatie in plaats van theorie; deelnemers leren hoe ze van domeinmodellering en serviceontwerp naar implementatie, observabiliteit en robuustheid in productieomgevingen komen.

U zult actief een echte microservices-architectuur bouwen. Daarbij leert u hoe u veelvoorkomende valkuilen, zoals gedistribueerde monolieten, kunt vermijden en hoe u best practices hanteert voor schaalbaarheid, beheerbaarheid en operationele excellentie.

Deze live-training onder leiding van een instructeur in Leiden (online of ter plaatse) richt zich op systeembeheerders en IBM MQ-beheerders die hun kennis willen verdiepen over geavanceerde configuratie, beveiliging, clustering, hoge beschikbaarheid en probleemoplossing van IBM MQ 9.4 in gedistribueerde omgevingen.

Dit cursusprogramma is bedoeld voor enterprise-architecten, ontwikkelaars, systeembeheerders en iedereen die een hoogwaardig distributief berichtensysteem wil begrijpen en gebruiken. Mocht u specifieke behoeften hebben (bijvoorbeeld alleen op het gebied van systeembeheer), dan kan deze cursus aangepast worden om beter aan uw wensen te voldoen.

Deze door een docent geleide, live-training in Leiden (online of op locatie) is bedoeld voor systeembeheerders en operations-engineers van beginner-, intermediair- of gevorderd niveau die Apache Kafka willen gebruiken om clusters te implementeren, beveiligen, te monitoren en te troubleshooten.

Na afloop van de cursus kunnen deelnemers de architectuur van Kafka en KRaft-modus uitleggen, clusters veilig beheren, prestaties en betrouwbaarheid monitoren, en veelvoorkomende productieproblemen oplossen.

In deze interactieve, door een instructeur geleide training in Leiden leren deelnemers hoe zij microservices kunnen bouwen met Go (Golang) en Spring Cloud.

Deze door een instructeur geleide live-training in Leiden (online of op locatie) is bedoeld voor softwareontwikkelaars, systeemarchitecten en DevOps-professionals met gemiddelde kennis die graag schaalbare en onderhoudbare applicaties willen bouwen middels een microservices-architectuur.

Na afloop van de training zijn deelnemers in staat om:

• De belangrijkste principes van microservice-architecturen te begrijpen.
• Schaalbare, op microservices gebaseerde systemen te ontwerpen en implementeren.
• Gebruik te maken van ontwerppatronen en best practices voor microservices.
• Eventgedreven benaderingen zoals CQRS en event sourcing toe te passen.
• Uitdagingen bij systeemoperaties en de implementatie van microservices het hoofd te bieden.

Tijdens deze begeleide, praktijkgerichte training leren deelnemers hoe ze microservices kunnen bouwen met behulp van Spring Cloud en Docker. De kennis wordt vervolgens getest door middel van oefeningen en het stap-voor-stap ontwikkelen van voorbeeld-microservices.

Aan het einde van de training zijn de deelnemers in staat om:

• De basisprincipes van microservices te begrijpen.
• Docker te gebruiken voor het maken van containers voor hun microservice-applicaties.
• Containergebaseerde microservices te ontwikkelen en te implementeren met Spring Cloud en Docker.
• Microservices te integreren met discovery services en de Spring Cloud API Gateway.
• Docker Compose in te zetten voor end-to-end integratietests.

WSO2 API Manager is een open-source platform voor het publiceren en beheren van API’s. Het is een ideale keuze voor het creëren van API-gedreven of IoT-gestuurde architecturen.

In deze door een instructor bege leidde live-training maken deelnemers kennis met de functies, concepten en standaarden achter WSO2 API Manager. Theoretische kennis wordt gecombineerd met live praktische oefeningen en implementatie tijdens de training. Aan het einde van de cursus hebben deelnemers de nodige kennis en ervaring om hun eigen API’s te implementeren met behulp van de kernfuncties van WSO2 API Manager.

Opzet van de cursus

• Interactieve lezingen en discussie.
• Veel oefeningen en praktijkcases.
• Hands-on implementatie in een live-lab omgeving.

Mogelijkheden voor aanpassing van de cursus

• Wilt u een aangepaste training voor deze cursus aanvragen? Neem contact met ons op om dit te regelen.