VOOZH about

URL: https://www.coursera.org/learn/packt-advanced-spring-cloud-microservices-and-deployment-with-docker-1nbvc

⇱ Advanced Spring Cloud Microservices & Deployment with Docker | Coursera

Advanced Spring Cloud Microservices & Deployment with Docker

Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Advanced Spring Cloud Microservices & Deployment with Docker

1,990 already enrolled

Included with

Ask Coursera

Gain insight into a topic and learn the fundamentals.
Intermediate level

Recommended experience

1 week to complete
at 10 hours a week
Flexible schedule
Learn at your own pace
Gain insight into a topic and learn the fundamentals.
Intermediate level

Recommended experience

1 week to complete
at 10 hours a week
Flexible schedule
Learn at your own pace

What you'll learn

  • Build resilient, scalable microservices using Spring Cloud & Spring Boot

  • Containerize and deploy services with Docker and Docker Compose

  • Implement observability using Zipkin and OpenTelemetry in microservices

  • Deploy and scale microservices in Kubernetes using GKE and YAML

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

6 assignments

Taught in English

Build your subject-matter expertise

This course is part of the Master Microservices with Spring Boot and Spring Cloud Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 4 modules in this course

This course features Coursera Coach! A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course.

This course empowers learners to master modern microservices architecture using Spring Cloud, Docker, and Kubernetes. You’ll gain a deep understanding of how to build scalable, resilient microservices while managing configuration, service discovery, routing, and observability across distributed systems. The journey begins with building foundational microservices like Currency Exchange and Currency Conversion using Spring Cloud. You’ll explore essential components such as Spring Cloud Config Server, Eureka Naming Server, and API Gateway. With hands-on examples, you'll implement load balancing, fault tolerance with Resilience4j, and centralized configuration using Git integration. Next, the course dives into containerization using Docker. You'll learn to build optimized Docker images, manage multi-container deployments with Docker Compose, and implement distributed tracing with Zipkin and OpenTelemetry. Finally, you’ll deploy your microservices in a Kubernetes environment on Google Cloud Platform (GCP), mastering YAML configurations, autoscaling, service discovery, and observability with GKE. This course is ideal for experienced Java developers, cloud engineers, or DevOps professionals looking to upskill in microservices architecture and cloud-native deployments. Familiarity with Spring Boot and basic cloud concepts is recommended. The course is rated at an Intermediate level due to its technical depth and deployment complexity. By the end of the course, you will be able to design, build, containerize, and deploy enterprise-grade microservices using Spring Cloud, Docker, and Kubernetes, with full observability and resilience.

In this module, we will dive deep into building robust microservices using the Spring Cloud ecosystem. You’ll start with foundational services like Limits and move toward a fully distributed architecture using Eureka, API Gateway, and Feign clients. We’ll also explore resilience techniques with Resilience4j and enhance observability through centralized config and dynamic routing.

What's included

32 videos2 readings1 assignment

32 videos•Total 189 minutes
  • Step 00 01 - Microservices Section Introduction•1 minute
  • Step 00 02 - Introduction to Centralized Configuration•2 minutes
  • Step 01 - Setting up Limits Microservice - V3•6 minutes
  • Step 02 - Creating a hard coded limits service - V3•5 minutes
  • Step 03 - Enhance limits service - Get configuration from application props - V3•4 minutes
  • Step 04 - Setting up Spring Cloud Config Server - V3•4 minutes
  • Step 05 - Installing Git and Creating Local Git Repository - V3•4 minutes
  • Step 06 - Connect Spring Cloud Config Server to Local Git Repository - V3•4 minutes
  • Step 07 - Connect Limits Service to Spring Cloud Config Server - V3•4 minutes
  • Step 08 - Configuring Profiles for Limits Service - V3•6 minutes
  • Debugging Guide for Microservices V3 + Docker + Docker Compose•3 minutes
  • Step 09 - Introduction to Currency Conversion & Exchange Microservices - V3•2 minutes
  • Step 10 - Setting up Currency Exchange Microservice - V3•4 minutes
  • Step 11 - Create a simple hard coded currency exchange service - V3•8 minutes
  • Step 12 - Setting up Dynamic Port in the Response - V3•6 minutes
  • Step 13 - Configure JPA and Initialized Data - V3•11 minutes
  • Step 14 - Create a JPA Repository - V3•6 minutes
  • Step 15 - Setting up Currency Conversion Microservice - V3•2 minutes
  • Step 16 - Creating a service for currency conversion - V3•7 minutes
  • Step 17 - Invoking Currency Exchange from Currency Conversion Microservice - V3•7 minutes
  • Step 18 - Using Feign REST Client for Service Invocation - V3•8 minutes
  • Step 19 - Understand Naming Server and Setting up Eureka Naming Server - V3•8 minutes
  • Step 20 - Connect Currency Conversion & Currency Exchange Microservices - V3•5 minutes
  • Step 22 - Load Balancing with Eureka, Feign & Spring Cloud LoadBalancer - V3•5 minutes
  • Step 22 - Setting up Spring Cloud API Gateway - V3•6 minutes
  • Step 23 - Enabling Discovery Locator with Eureka for Spring Cloud Gateway - V3•7 minutes
  • Step 24 - Exploring Routes with Spring Cloud Gateway - V3•14 minutes
  • Step 25 - Implementing Spring Cloud Gateway Logging Filter- V3•6 minutes
  • Step 26 - Getting started with Circuit Breaker - Resilience4j - V3•7 minutes
  • Step 27 - Playing with Resilience4j - Retry and Fallback Methods - V3•12 minutes
  • Step 28 - Playing with Circuit Breaker Features of Resilience4j - V3•9 minutes
  • Step 29 - Exploring Rate Limiting and BulkHead Features of Resilience4j - V3•6 minutes
2 readings•Total 20 minutes
  • Introduction to the course 'Advanced Spring Cloud Microservices & Deployment with Docker'•10 minutes
  • Full Course Resources•10 minutes
1 assignment•Total 15 minutes
  • Microservices with Spring Cloud - V3 - Assessment•15 minutes

In this module, we will focus on containerizing your Spring Boot applications using Docker, making it easier to deploy and scale microservices. You will learn how to create optimized Docker images, orchestrate multi-container deployments with Docker Compose, and implement distributed tracing for enhanced observability.

What's included

22 videos1 assignment

22 videos•Total 142 minutes
  • Step 00 - Match made in Heaven - Docker and Microservices•3 minutes
  • Step 01 - Installing Docker•4 minutes
  • Step 02 - Getting Started with Docker•5 minutes
  • Step 03 - Understanding Docker Fundamentals•6 minutes
  • Step 04 - Understanding How Docker Works•14 minutes
  • Step 05 - Understanding Docker Terminology•3 minutes
  • Step 06 - Creating Docker Image for a Spring Boot Project - Dockerfile•9 minutes
  • Step 07 - Building Spring Boot Docker Image using Multi Stage Dockerfile•8 minutes
  • Step 08 - Building Spring Boot Docker Image - Optimizing Dockerfile•8 minutes
  • Step 09 - Building Docker Image with Spring Boot Maven Plugin•7 minutes
  • Step 10 - Introduction to Distributed Tracing•2 minutes
  • Step 11 - Launching Zipkin Container using Docker•3 minutes
  • Step 12 00 - Getting Started with Observability and OpenTelemetry•3 minutes
  • Step 12 - Connecting Currency Exchange Microservice with Zipkin•13 minutes
  • Step 13 - Connecting Currency Conversion Microservice & API Gateway with Zipkin•13 minutes
  • Step 14 - Getting Setup with Microservices for Creating Container Images•5 minutes
  • Step 15 - Creating Container Image for Currency Exchange Microservice•10 minutes
  • Step 16 - Getting Started with Docker Compose - Currency Exchange Microservice•6 minutes
  • Step 17 - Running Eureka Naming Server with Docker Compose•7 minutes
  • Step 18 - Running Currency Conversion Microservice with Docker Compose•4 minutes
  • Step 19 - Running Spring Cloud API Gateway with Docker Compose•4 minutes
  • Step 20 - Running Zipkin with Docker Compose•4 minutes
1 assignment•Total 15 minutes
  • Docker with Microservices using Spring Boot and Spring Cloud - V3 - Assessment•15 minutes

In this module, we will take your microservices to the cloud by deploying them on Kubernetes using GCP’s Google Kubernetes Engine (GKE). You will learn how to configure and scale your microservices using Kubernetes YAML files, ensuring fault tolerance, health checks, and efficient management of services across your cluster.

What's included

31 videos1 assignment

31 videos•Total 177 minutes
  • Step 00 - Docker, Kubernetes and Microservices - Made for each other•3 minutes
  • Step 01 - Creating GCP - Google Cloud Platform - Account•2 minutes
  • Step 02 - Kubernetes Journey - Creating a GKE Cluster•4 minutes
  • Step 03 - Kubernetes Journey - Create a Deployment and a Service•8 minutes
  • Step 04 - Exploring GKE in GCP Console•6 minutes
  • Step 05 - Kubernetes Journey - Scaling Deployments and Resizing Node Pools•7 minutes
  • Step 06 - Kubernetes Journey - Autoscaling, Config Map and Secrets•7 minutes
  • Step 07 - Exploring Kubernetes Deployments with YAML Declarative Configuration•4 minutes
  • Step 08 - Kubernetes Journey - The End•4 minutes
  • Step 09 - Understanding Kubernetes Clusters - Google Kubernetes Engine GKE•3 minutes
  • Step 10 - Understanding Pods in Kubernetes•3 minutes
  • Step 11 - Understanding Deployments and Replica Sets in Kubernetes•7 minutes
  • Step 12 - Understanding Services in Kubernetes•5 minutes
  • Step 13 - 01 Installing Gcloud•5 minutes
  • Step 13 - 02 Installing Kubectl•3 minutes
  • Step 13 03 - Understanding Kubernetes Architecture - Master Node and Nodes•8 minutes
  • Step 14 - Setup Currency Exchange & Conversion Microservices - Kubernetes•9 minutes
  • Step 15 - Container images for Exchange & Currency Conversion Microservices•6 minutes
  • Step 16 - Deploy Microservices to Kubernetes & Understand Service Discovery•10 minutes
  • Step 17 - Creating Declarative Configuration Kubernetes YAML for Microservices•8 minutes
  • Step 18 - Clean up Kubernetes YAML for Microservices•7 minutes
  • Step 19 - Enable Logging and Tracing APIs in Google Cloud Platform•2 minutes
  • Step 20 - Deploying Microservices using Kubernetes YAML Configuration•4 minutes
  • Step 21 - Playing with Kubernetes Declarative YAML Configuration•4 minutes
  • Step 22 - Creating Environment Variables to enable Microservice Communication•10 minutes
  • Step 23 - Understanding Centralized Configuration in Kubernetes - Config Maps•7 minutes
  • Step 24 - Exploring Centralized Logging and Monitoring in GKE•6 minutes
  • Step 25 - Exploring Microservices Deployments with Kubernetes•8 minutes
  • Step 26 - Configuring Liveness and Readiness Probes for Microservices with K8S•9 minutes
  • Step 27 - Autoscaling Microservices with Kubernetes•7 minutes
  • Step 28 - Delete Kubernetes Cluster and Thank You!•1 minute
1 assignment•Total 15 minutes
  • Kubernetes with Microservices using Docker, Spring Boot and Spring Cloud - V3 - Assessment•15 minutes

In this final module, we will wrap up the course by summarizing the key concepts you’ve learned. We will reflect on your journey to mastering microservices and cloud-native application development, while providing guidance on next steps for applying these skills in professional projects.

What's included

1 video1 reading3 assignments

1 video•Total 1 minute
  • Master Microservices with Spring Boot and Spring Cloud - Congratulations•1 minute
1 reading•Total 10 minutes
  • Conclusion to the Course 'Advanced Spring Cloud Microservices & Deployment with Docker'•10 minutes
3 assignments•Total 90 minutes
  • Thanks - Assessment•15 minutes
  • Full Course Assessment•60 minutes
  • Full Course Practice Assessment•15 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Offered by

Explore more from Software Development

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Frequently asked questions

This course focuses on designing, developing, and deploying microservices using Spring Cloud and Docker. It explores how to build scalable, fault-tolerant systems where independent services work together seamlessly. In today’s cloud-native ecosystem, the combination of microservices architecture with Docker containerization is crucial for achieving agility, scalability, and easy deployment across different environments.

This course provides an in-depth, hands-on learning experience for developers who want to master microservices architecture using Spring Boot, Spring Cloud, and Docker. It covers key concepts like centralized configuration, service discovery with Eureka, load balancing, API gateways, circuit breakers with Resilience4j, distributed tracing using Zipkin, and containerization with Docker and Docker Compose. Learners also explore deployment to Kubernetes using Google Kubernetes Engine (GKE), achieving full-scale cloud-native microservices deployment.

After completing this course, you will be able to design and implement advanced microservice architectures using Spring Cloud, manage configurations and communication between services, deploy microservices as Docker containers, and orchestrate multi-container setups using Docker Compose. You will also gain the ability to deploy, scale, and monitor your microservices in Kubernetes environments using Google Cloud Platform. These skills will equip you to build robust, scalable, and production-ready microservices applications.

Learners should have a solid understanding of Java programming and familiarity with Spring Boot fundamentals. Basic knowledge of REST APIs, Maven, and Git will be helpful. Prior exposure to microservices or containerization concepts is advantageous but not mandatory, as the course begins with foundational setup and progressively advances to complex deployments and integrations.

This course is ideal for Java developers, software engineers, DevOps professionals, and anyone interested in mastering the deployment and orchestration of microservices using Spring Cloud and Docker. It is especially beneficial for developers aiming to transition from monolithic architectures to modern, distributed systems that are easier to scale and maintain.

The course contains approximately 10 hours of video content. Learners who follow along with the practical exercises and complete the hands-on projects can expect to finish it comfortably within two to three weeks, depending on their pace and prior experience.

Yes, in addition to Docker and Docker Compose, the course extends into Kubernetes deployment using Google Kubernetes Engine (GKE). Learners will gain experience in managing deployments, scaling microservices, configuring load balancing, and enabling observability through centralized logging and tracing in Kubernetes environments.

Throughout the course, you will work with Spring Boot, Spring Cloud Config, Eureka Naming Server, Feign Client, Spring Cloud Gateway, Resilience4j, Zipkin, Docker, Docker Compose, Kubernetes, and Google Cloud Platform. These tools together form a complete technology stack for developing, deploying, and managing production-grade microservices.

To access the course materials, assignments and to earn a Certificate, you will need to purchase the Certificate experience when you enroll in a course. You can try a Free Trial instead, or apply for Financial Aid. The course may offer 'Full Course, No Certificate' instead. This option lets you see all course materials, submit required assessments, and get a final grade. This also means that you will not be able to purchase a Certificate experience.

When you enroll in the course, you get access to all of the courses in the Specialization, and you earn a certificate when you complete the work. Your electronic Certificate will be added to your Accomplishments page - from there, you can print your Certificate or add it to your LinkedIn profile.

Yes. In select learning programs, you can apply for financial aid or a scholarship if you can’t afford the enrollment fee. If fin aid or scholarship is available for your learning program selection, you’ll find a link to apply on the description page.

Financial aid available,