Become a Pro in Spring Boot, Micronaut, Kafka & Containerisation – Build, Deploy, and Scale Microservices with Confidence!
Course Overview: This program offers a hands-on journey from foundational to advanced skills in backend Java development and microservices architecture. Core topics include: 1) Building robust microservices using Spring Boot and Micronaut 2) Developing event-driven systems with Apache Kafka and AKHQ 3) Mastering Java versions 11 through 24 with modern programming paradigms 4) Containerizing applications using Docker and orchestrating with Docker Compose 5) Implementing CI/CD pipelines using GitHub Actions for streamlined automation and delivery. Throughout this course, you'll work with real-world tools and scenarios to gain the skills required to develop, test, deploy, and manage cloud-native microservices in production environments.
Course Description
Accelerate your journey to becoming a high-impact full-stack developer with in-demand skills in Spring Boot, Micronaut, Kafka, Docker, and Docker Compose. This 6-month hands-on course is designed to turn you from a beginner into a confident developer ready to build, containerize, and manage cloud-native microservices in real-world enterprise environments. You’ll gain deep expertise in core Java by mastering key features from Java 11, 17, 21, and even Java 24. From modern syntax improvements and enhanced APIs to virtual threads and pattern matching, you’ll write cleaner, faster, and more maintainable code using the latest that the Java platform offers. On the backend, you'll explore both Spring Boot and Micronaut in depth—learning how to create robust RESTful APIs, handle dependency injection, manage configuration, integrate with databases, and build reactive and event-driven services. You'll understand where each framework shines and how to leverage their strengths in different real-world scenarios. You’ll also work with Apache Kafka to build scalable, event-driven systems, and use Docker and Docker Compose to containerize and orchestrate multi-service applications in your local development environment—just like in real-world microservices deployments. Throughout the course, you’ll build hands-on projects and gain experience with continuous integration and deployment (CI/CD) using GitHub Actions. You'll develop the skills to test, deploy, and monitor applications effectively in cloud-native environments. By the end of this program, you'll have a strong portfolio showcasing your capabilities in modern Java development, microservices architecture, containerization, and automation. Whether you’re breaking into the industry or advancing your current role, this course will give you the tools to stand out as a backend and microservices developer.
Fee Breakdown
📆 Then, pay £427.55/month for 5 months.
Choose Your Ideal Start Date!
Key Technology Tags
Features
Seats Available:25 seats
Instructed In:English
Installment Allowed:Yes
Instructor:Edwin Nwofor
Delivery Mode:Online
Next Starting:01/10/2025
Duration:6 months
Institution:CEN IDEA LTD
Before You Begin – What You Need to Know!
Make sure you're ready for this course by reviewing these key prerequisites.
- A foundational understanding of Java programming is expected, including familiarity with object-oriented principles such as classes, inheritance, polymorphism, and interfaces. Prior experience writing basic Java applications will help you follow along with the more advanced topics covered in this course.
- You should have basic working knowledge of Git and version control workflows. This includes tasks such as cloning repositories, committing changes, branching, and merging—skills that are essential for collaborative development and CI/CD pipelines.
- An eagerness to explore cloud-native technologies and modern DevOps practices is crucial. This course will involve hands-on work with tools like Docker, Docker Compose, and CI/CD automation, so a proactive learning mindset will help you make the most of the material.
- Familiarity with basic command-line operations in Linux or macOS environments is recommended, as much of the development and deployment work will be done using terminal-based tools.
- An understanding of how web applications work, particularly RESTful APIs and HTTP protocols, will enhance your ability to grasp backend and microservice design concepts introduced throughout the course.
What You'll Gain from This Course
- Enable students to design, develop, and deploy microservices using both Spring Boot and Micronaut, understanding the architectural principles and advanced features of each framework.
- Introduce students to event-driven microservices and message-based communication using Apache Kafka, along with tools like AKHQ for monitoring message flows.
- Provide hands-on experience in containerization using Docker, and teach orchestration and local microservices management using Docker Compose for multi-service setups.
- Help students build robust and testable backend systems by applying integration testing, unit testing, and mocking techniques within Spring Boot and Micronaut environments.
- Develop students' ability to work with real-world microservice architectures by implementing local development workflows, configuration management, and runtime observability with tools like environment variables and log analysis.
- Strengthen core Java programming skills by mastering key features across Java versions 11, 17, 21, and 24, including modern language enhancements, performance improvements, and API upgrades.
Course Syllabus
- Installing JDK and Development Tools (Java 17, 21, 24)
- Understanding JVM, JRE, JDK and Compilation Process
- Data Types, Control Structures, Arrays, and Loops
- Object-Oriented Programming in Java: Classes, Objects, Inheritance
- Interfaces, Abstract Classes, and Polymorphism
- Exception Handling and Custom Exceptions
- Collections Framework: List, Set, Map
- Java Streams API and Functional Programming
- Key Features in Java 11–24: var, records, pattern matching, switch expressions
- Working with Files and I/O Streams
- Multithreading, Concurrency and Executors
- Using Modern Java APIs (Optional, Sealed, Virtual Threads)
- Spring Boot Introduction and Architecture
- Creating Your First Spring Boot Application
- Spring Boot Auto-configuration and Starter Dependencies
- Profiles, Application Properties, and Logging
- RESTful API Development in Spring Boot
- DTOs, Validation, and Exception Handling
- Spring Data JPA and Integration with H2/Postgres
- Building CRUD Services
- Introduction to Spring Security & Authentication
- Securing APIs with JWT Tokens
- Unit Testing with JUnit & Mockito
- Integration Testing in Spring Boot
- Introduction to Micronaut Framework
- Micronaut vs Spring Boot: Key Differences
- Dependency Injection and Configuration in Micronaut
- Building Your First Micronaut Microservice
- Creating REST Endpoints with Micronaut
- HTTP Client Communication and Error Handling
- Unit and Integration Testing in Micronaut
- Micronaut Profiles and Configuration Management
- Kafka Fundamentals: Topics, Partitions, Producers, Consumers
- Creating Kafka Producer and Consumer with Java
- Integrating Kafka with Spring Boot and Micronaut
- Monitoring Kafka Topics using AKHQ
- Introduction to Docker: Images, Containers, Registries
- Writing Dockerfiles for Spring Boot and Micronaut
- Building and Running Docker Containers
- Optimizing Docker Images and Using Multi-stage Builds
- Using Docker Compose for Multi-Container Applications
- Managing Microservices and Kafka with Docker Compose
- Environment Variables and Volume Mounting
- Building Local Development Environments with Docker Compose
- Introduction to CI/CD Concepts
- Creating GitHub Actions Workflows for Java Projects
- Running Unit and Integration Tests in Pipelines
- Building and Pushing Docker Images via GitHub Actions
- Structured Logging in Spring Boot and Micronaut
- Monitoring with Open-source Tools (Log Aggregators, JSON Logs)
- Application Metrics and Health Checks
- Observability Patterns and Alerting Basics
- Global Exception Handling Strategies
- Retry, Timeout, and Circuit Breakers with Resilience4j
- Configuring Error Pages and Custom Responses
- Fail-Safe Communication in Distributed Systems
- Spring Boot Actuator for Monitoring
- Custom Starters and Auto-configuration
- Asynchronous Programming and Scheduling
- Caching and Performance Optimization Techniques
- Micronaut AOP and Bean Lifecycle
- Reactive Programming with Micronaut
- Compile-Time Dependency Injection Advantages
- Micronaut CLI and Command Line Runners
- Spring Data JPA: Relationships, Transactions, Queries
- Micronaut Data: Repositories and Custom Queries
- Working with PostgreSQL in Docker
- Database Migrations with Flyway or Liquibase
- Service Registry, Configuration Management Patterns
- API Gateway and BFF Concepts
- Communication Patterns: REST vs Messaging
- Service Discovery & Versioning Strategies
- OAuth2 and JWT Overview
- Role-based Access Control (RBAC)
- Token Validation & Expiration
- Best Practices for Securing Distributed Systems
- Branching Strategies and PR Workflows
- Tagging, Releases, and Git Hooks
- Automated Deployment Strategies
- DevOps Culture and Feedback Loops
- Defining Use Cases and Architecture
- Choosing Between Spring Boot and Micronaut
- CI/CD Pipeline Design and Repository Setup
- Mocking External Dependencies
- Developing Microservices and Integrating Kafka
- Setting Up Docker Compose for Local Testing
- CI/CD Pipeline Execution and Debugging
- Initial Deployment and Feedback Review
- Finalizing Features and Testing Coverage
- Implementing Observability and Logs
- Peer Review and Code Refactoring
- Project Presentation Planning
- Student Presentations and Feedback
- Live Demonstrations of Microservices
- Portfolio Publishing Tips and GitHub Setup
- Career Guidance: Next Steps and Opportunities
No Reviews on this room