Building Microservices with Go Training Course

Confluent Apache Kafka is a distributed event streaming platform engineered for high-throughput, fault-tolerant data pipelines and real-time analytics.

This instructor-led live training (available online or on-site) targets intermediate-level system administrators and DevOps professionals seeking to install, configure, monitor, and troubleshoot Confluent Apache Kafka clusters.

Upon completion of this training, participants will be able to:

• Grasp the components and architecture of Confluent Kafka.
• Deploy and manage Kafka brokers, Zookeeper quorums, and essential services.
• Configure advanced features such as security, replication, and performance tuning.
• Utilise management tools to monitor and maintain Kafka clusters effectively.

Course Format

• Interactive lecture and discussion.
• Extensive exercises and practical work.
• Hands-on implementation within a live-lab environment.

Course Customisation Options

• To request customised training for this course, please contact us to arrange.

This instructor-led, live training in the Netherlands (online or onsite) is designed for developers and software engineers who wish to use RabbitMQ to facilitate communication between microservices via messaging, as well as perform advanced implementation and troubleshooting.

Upon completing this training, participants will be able to:

• Set up the necessary environment to begin developing advanced messaging solutions with RabbitMQ.
• Understand how to design a distributed microservices architecture using RabbitMQ.
• Learn to implement advanced configuration, security, networking, high availability, and replication strategies.
• Identify common issues encountered in RabbitMQ installations and know how to resolve them.
• Gain knowledge of memory optimization, flow control, and advanced performance tuning.
• Apply various advanced troubleshooting techniques.

This instructor-led, live training in the Netherlands (online or onsite) is designed for developers, integration architects, and system administrators seeking to master advanced integration patterns and techniques using Apache Camel.

Upon completion of this training, participants will be able to:

• Comprehend advanced integration patterns and techniques.
• Execute complex routing and data transformations.
• Enhance performance and scalability.
• Manage errors and exceptions within complex integration scenarios.
• Seamlessly integrate Apache Camel with various technologies and platforms.

Apache Camel offers a powerful framework designed for enterprise application integration and message routing. This course covers essential topics such as routing mechanisms, message transformation, error handling strategies, component connectivity, Enterprise Integration Patterns, and transaction management. It guides developers through practical aspects like configuring route definitions, wiring beans, managing concurrency, and implementing monitoring solutions. Participants will gain the skills needed to build reliable microservice communication layers and optimize data workflows.

This instructor-led, live training in the Netherlands (online or onsite) is designed for developers who want to learn how to build, test, debug, and deploy an API on top of Google Cloud's Apigee API Platform.

By the end of this training, participants will be able to:

• Configure a development environment with all necessary resources to begin developing an API.
• Understand and apply the tools available within Apigee Edge.
• Construct and deploy an API on Google Cloud.
• Monitor the API and troubleshoot errors.
• Utilize Google Cloud's analytics and machine learning solutions to enhance the intelligence of APIs.

Apigee Edge, which is built on Java, enables you to provide secure access to your services with a well-defined API that is consistent across all of your services, regardless of service implementation. A consistent API:

• Makes it easy for app developers to consume your services.
• Enables you to change the backend service implementation without affecting the public API.
• Enables you to take advantage of the analytics, monetization, developer portal, and other features built into Edge.

Audience

This course is directed at engineers, architects and developers seeking to utilize Apigee Edge in their projects.

Confluent Apache Kafka is an enterprise-grade distributed event streaming platform built on Apache Kafka. It supports high-throughput, fault-tolerant data pipelines and real-time streaming applications.

This instructor-led, live training (online or onsite) is aimed at intermediate-level engineers and administrators who wish to deploy, configure, and optimize Confluent Kafka clusters in production environments.

By the end of this training, participants will be able to:

• Install, configure, and operate Confluent Kafka clusters with multiple brokers.
• Design high-availability setups using Zookeeper and replication techniques.
• Tune performance, monitor metrics, and apply recovery strategies.
• Secure, scale, and integrate Kafka with enterprise environments.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Istio serves as an open-source service mesh operating on Kubernetes to deliver secure, observable, and manageable connectivity between microservices. By utilizing Istio’s Envoy-based sidecar proxies, teams can enforce policies, secure communications through mTLS, gain deep traffic observability, and enhance reliability at scale.

This instructor-led, live training (available online or onsite) targets intermediate-level engineers looking to deploy, secure, and manage microservices applications using Istio on Kubernetes.

Upon completing this training, participants will be capable of:

• Installing and configuring Istio on Kubernetes clusters.
• Understanding and applying service mesh concepts such as traffic management, security, and observability.
• Deploying microservices applications within an Istio service mesh.
• Securing service-to-service communications using mutual TLS (mTLS) and Zero Trust principles.
• Monitoring, tracing, and troubleshooting microservices with Prometheus, Grafana, and Jaeger.
• Integrating Istio with Calico for advanced network policies and security.

Course Format

• Interactive lecture and discussion.
• Numerous exercises and practical sessions.
• Hands-on implementation in a live laboratory environment.

Customization Options

• To request customized training for this course, please contact us to arrange arrangements.

This instructor-led, live training in the Netherlands (online or onsite) is aimed at intermediate-level Java developers who wish to design, develop, deploy, and maintain microservices-based applications using Java frameworks like Spring Boot and Spring Cloud.

By the end of this training, participants will be able to:

• Understand the principles and benefits of microservices architecture.
• Build and deploy microservices using Java and Spring Boot.
• Implement service discovery, configuration management, and API gateways.
• Secure, monitor, and scale microservices effectively.
• Deploy microservices using Docker and Kubernetes.

Designed for enterprise architects, developers, system administrators, and professionals seeking to grasp and implement a high-throughput distributed messaging platform. Should you have specific needs (such as focusing exclusively on system administration), the course can be customized to align with your requirements.

This instructor-led, live training in the Netherlands (online or onsite) is aimed at beginner-level, intermediate-level, and advanced-level system administrators and operations engineers who wish to use Apache Kafka to deploy, secure, monitor, and troubleshoot Kafka clusters.

By the end of this training, participants will be able to explain Kafka architecture and KRaft mode, operate and secure Kafka clusters, monitor performance and reliability, and resolve common production issues.

This instructor-led, live training in the Netherlands (online or onsite) is aimed at intermediate-level developers who wish to develop big data applications with Apache Kafka.

By the end of this training, participants will be able to:

• Develop Kafka producers and consumers to send and read data from Kafka.
• Integrate Kafka with external systems using Kafka Connect.
• Write streaming applications with Kafka Streams & ksqlDB.
• Integrate a Kafka client application with Confluent Cloud for cloud-based Kafka deployments.
• Gain practical experience through hands-on exercises and real-world use cases.

This instructor-led live training in the Netherlands (online or onsite) is aimed at intermediate-level Java developers who wish to integrate Apache Kafka into their applications for reliable, scalable, and high-throughput messaging.

By the end of this training, participants will be able to:

• Understand the architecture and core components of Kafka.
• Set up and configure a Kafka cluster.
• Produce and consume messages using Java.
• Implement Kafka Streams for real-time data processing.
• Ensure fault tolerance and scalability in Kafka applications.

In this instructor-led, live training held at the Netherlands, participants will learn the fundamentals of building microservices using Spring Cloud and Docker. Participant knowledge is put to the test through exercises and the step-by-step development of sample microservices.

By the end of this training, participants will be able to:

• Understand the fundamentals of microservices.
• Use Docker to build containers for microservice applications.
• Build and deploy containerized microservices using Spring Cloud and Docker.
• Integrate microservices with discovery services and the Spring Cloud API Gateway.
• Use Docker Compose for end-to-end integration testing.

This instructor-led live training in the Netherlands (online or onsite) is aimed at intermediate-level developers and DevOps engineers who wish to build, deploy, and manage microservices using Spring Cloud and Docker.

By the end of this training, participants will be able to:

• Develop microservices using Spring Boot and Spring Cloud.
• Containerize applications with Docker and Docker Compose.
• Implement service discovery, API gateways, and inter-service communication.
• Monitor and secure microservices in production environments.
• Deploy and orchestrate microservices using Kubernetes.